@desplega.ai/agent-swarm 1.149.0 → 1.150.0

package/dist/{cli-ygweqcn4.js → cli-rwp3ksm7.js}

@@ -12,20 +12,20 @@ import {
   renderAutomationTokens,
   schedulePreflightInput,
   startWorkflowExecution
-} from "./cli-6pqcb4q0.js";
+} from "./cli-rnsr8asm.js";
 import {
   buildScriptCredentialBindings,
   getScript,
   getScriptApiConnectionDescriptors,
   getScriptMcpConnectionDescriptors,
   runScript
-} from "./cli-aae6hz6a.js";
+} from "./cli-zd21jrrc.js";
 import {
   createTaskWithSiblingAwareness
-} from "./cli-q50ef8g0.js";
+} from "./cli-n1yj5fd5.js";
 import {
   ensure
-} from "./cli-d8ftsp62.js";
+} from "./cli-kt7wevqh.js";
 import {
   getDbClient,
   getDueScheduledTasks,
@@ -39,7 +39,7 @@ import {
   scheduleContextKey,
   telemetry,
   updateScheduledTask
-} from "./cli-yab68w40.js";
+} from "./cli-qp69dd5d.js";
 import {
   init_event_bus,
   workflowEventBus
@@ -72,6 +72,7 @@ async function createStandaloneScheduleTask(schedule, extraTags = []) {
     priority: schedule.priority,
     agentId: schedule.targetAgentId,
     routingReason: schedule.targetAgentId ? "human_pinned" : undefined,
+    routingSource: schedule.targetAgentId ? "engine_default" : undefined,
     model: schedule.model,
     modelTier: schedule.modelTier,
     scheduleId: schedule.id,
@@ -81,7 +82,10 @@ async function createStandaloneScheduleTask(schedule, extraTags = []) {
     parentTaskId: schedule.parentTaskId
   });
   if (schedule.taskType === "deferred" && schedule.parentTaskId) {
-    await getDbClient().run("UPDATE deferred_task_waits SET taskId = ?, updated_at = ? WHERE status = 'pending' AND taskId = ?", [task.id, new Date().toISOString(), schedule.parentTaskId]);
+    await getDbClient().run(`UPDATE deferred_task_wait_members SET taskId = ?, updated_at = ?
+       WHERE taskId = ? AND scheduleId IN (
+         SELECT scheduleId FROM deferred_task_waits WHERE status = 'pending'
+       )`, [task.id, new Date().toISOString(), schedule.parentTaskId]);
   }
   return task;
 }
@@ -102,6 +106,19 @@ async function dispatchDeferredTaskWait(scheduleId, reason, extraTags = []) {
     let schedule = await getScheduledTaskById(scheduleId);
     if (!schedule?.enabled)
       return {};
+    let cause = "ceiling expired";
+    if (reason !== "ceiling") {
+      const members = await client.query(`SELECT m.taskId, t.status AS taskStatus, EXISTS (
+           SELECT 1 FROM scheduled_tasks d
+           WHERE d.parentTaskId = t.id AND d.taskType = 'deferred' AND d.enabled = 1
+         ) AS deferred
+         FROM deferred_task_wait_members m LEFT JOIN agent_tasks t ON t.id = m.taskId
+         WHERE m.scheduleId = ?`, [scheduleId]);
+      const matched = members.filter((member) => !member.deferred && (member.taskStatus === "completed" || member.taskStatus === "failed") && (wait.eventName === "settled" || wait.eventName === `task.${member.taskStatus}`));
+      if (!matched.length || wait.mode === "all" && matched.length !== members.length)
+        return {};
+      cause = members.length === 1 ? `task.${matched[0].taskStatus} for task ${matched[0].taskId}` : `${wait.mode} tasks matched ${wait.eventName}: ${matched.map((member) => `${member.taskId} (${member.taskStatus})`).join(", ")}`;
+    }
     const now = new Date().toISOString();
     const claimed = await client.run("UPDATE deferred_task_waits SET status = 'fired', firedBy = ?, resolvedAt = ?, updated_at = ? WHERE scheduleId = ? AND status = 'pending'", [reason, now, now, scheduleId]);
     if (!claimed.changes)
@@ -111,7 +128,6 @@ async function dispatchDeferredTaskWait(scheduleId, reason, extraTags = []) {
     }
     if (!schedule.taskTemplate)
       throw new Error(`Schedule "${schedule.name}" has no taskTemplate`);
-    const cause = reason === "ceiling" ? "ceiling expired" : `${reason} for task ${wait.taskId}`;
     const task = await createStandaloneScheduleTask({
       ...schedule,
       taskTemplate: `${schedule.taskTemplate}
@@ -135,8 +151,9 @@ Wake-up cause: ${cause}.`
   });
 }
 async function reconcileDeferredTaskWaits(taskId) {
-  const rows = await getDbClient().query(`SELECT w.*, t.status AS taskStatus FROM deferred_task_waits w
-     JOIN agent_tasks t ON t.id = w.taskId
+  const rows = await getDbClient().query(`SELECT DISTINCT w.*, t.status AS taskStatus FROM deferred_task_waits w
+     JOIN deferred_task_wait_members m ON m.scheduleId = w.scheduleId
+     JOIN agent_tasks t ON t.id = m.taskId
      JOIN scheduled_tasks s ON s.id = w.scheduleId
      WHERE w.status = 'pending' AND s.enabled = 1 AND t.status IN ('completed', 'failed')
        AND NOT EXISTS (
@@ -144,7 +161,7 @@ async function reconcileDeferredTaskWaits(taskId) {
          WHERE d.parentTaskId = t.id AND d.taskType = 'deferred' AND d.enabled = 1
        )
        AND (w.eventName = 'settled' OR w.eventName = 'task.' || t.status)
-       ${taskId ? "AND w.taskId = ?" : ""}`, taskId ? [taskId] : []);
+       ${taskId ? "AND m.taskId = ?" : ""}`, taskId ? [taskId] : []);
   for (const row of rows) {
     try {
       await dispatchDeferredTaskWait(row.scheduleId, `task.${row.taskStatus}`);
@@ -173,6 +190,7 @@ function stopDeferredTaskWaits() {
 
 // src/scheduler/scheduler.ts
 var schedulerInterval = null;
+var schedulerRun = null;
 var isProcessing = false;
 var executorRegistry = null;
 function resolveExecutorRegistry() {
@@ -300,77 +318,50 @@ async function throwIfWorkflowNeedsSetup(scheduleId, runIds) {
     throw new AutomationNeedsSetupError(run.error);
   }
 }
-async function advanceScheduleAfterNeedsSetup(schedule, now = new Date) {
-  schedule = renderScheduledTaskParams(schedule);
-  const timestamp = now.toISOString();
-  if (schedule.scheduleType === "one_time") {
-    await updateScheduledTask(schedule.id, {
-      nextRunAt: null,
-      lastUpdatedAt: timestamp
+async function claimScheduleOccurrence(snapshot, extraTags) {
+  return getDbClient().transaction(async () => {
+    const current = await getScheduledTaskById(snapshot.id);
+    if (!current?.enabled || !current.nextRunAt || current.nextRunAt !== snapshot.nextRunAt) {
+      return null;
+    }
+    const schedule = renderScheduledTaskParams(current);
+    const deferred = await dispatchDeferredTaskWait(schedule.id, "ceiling", extraTags);
+    if (deferred) {
+      return {
+        schedule,
+        claimed: await getScheduledTaskById(schedule.id),
+        dispatched: { triggeredWorkflows: false, ...deferred }
+      };
+    }
+    const now = new Date;
+    const nextRunAt = schedule.scheduleType === "one_time" ? null : calculateNextRun(schedule.timezone?.includes("{{") ? { ...schedule, timezone: "UTC" } : schedule, new Date(Math.max(now.getTime(), new Date(current.nextRunAt).getTime())));
+    const claimed = await updateScheduledTask(schedule.id, {
+      lastRunAt: now.toISOString(),
+      nextRunAt,
+      ...schedule.scheduleType === "one_time" ? { enabled: false } : {}
     });
-    return;
-  }
-  await updateScheduledTask(schedule.id, {
-    nextRunAt: calculateNextRun(schedule.timezone?.includes("{{") ? { ...schedule, timezone: "UTC" } : schedule, now),
-    lastUpdatedAt: timestamp
+    return { schedule, claimed, dispatched: undefined };
+  });
+}
+async function updateClaimedSchedule(claimed, updates) {
+  await getDbClient().transaction(async () => {
+    const current = await getScheduledTaskById(claimed.id);
+    if (current?.nextRunAt !== claimed.nextRunAt || current?.lastRunAt !== claimed.lastRunAt || current?.enabled !== claimed.enabled || current?.lastUpdatedAt !== claimed.lastUpdatedAt)
+      return;
+    await updateScheduledTask(claimed.id, updates);
   });
 }
 async function recoverMissedSchedules() {
-  const now = new Date;
+  const now = Date.now();
   const dueSchedules = await getDueScheduledTasks();
-  for (const storedSchedule of dueSchedules) {
-    const schedule = renderScheduledTaskParams(storedSchedule);
+  for (const schedule of dueSchedules) {
     if (!schedule.nextRunAt)
       continue;
-    const missedBy = now.getTime() - new Date(schedule.nextRunAt).getTime();
+    const missedBy = now - new Date(schedule.nextRunAt).getTime();
     if (missedBy < 15000)
       continue;
     console.log(`[Scheduler] Recovering missed schedule "${schedule.name}" ` + `(was due ${Math.round(missedBy / 1000)}s ago)`);
-    let triggeredWorkflows = false;
-    try {
-      ({ triggeredWorkflows } = await dispatchScheduleTarget(schedule, ["recovered"]));
-      if (schedule.scheduleType === "one_time") {
-        await updateScheduledTask(schedule.id, {
-          lastRunAt: now.toISOString(),
-          nextRunAt: null,
-          enabled: false,
-          lastUpdatedAt: now.toISOString()
-        });
-      } else {
-        const nextRun = calculateNextRun(schedule, now);
-        await updateScheduledTask(schedule.id, {
-          lastRunAt: now.toISOString(),
-          nextRunAt: nextRun,
-          lastUpdatedAt: now.toISOString()
-        });
-      }
-      if (schedule.scheduleType === "one_time") {
-        console.log(`[Scheduler] One-time schedule "${schedule.name}" recovered and auto-disabled`);
-      }
-      telemetry.schedule("executed", {
-        scheduleType: schedule.scheduleType,
-        triggeredWorkflows,
-        wasRecovered: true
-      });
-    } catch (err) {
-      if (err instanceof AutomationNeedsSetupError) {
-        await advanceScheduleAfterNeedsSetup(schedule, now);
-        telemetry.schedule("error", {
-          scheduleType: schedule.scheduleType,
-          triggeredWorkflows,
-          wasRecovered: true,
-          consecutiveErrors: schedule.consecutiveErrors ?? 0
-        });
-        continue;
-      }
-      telemetry.schedule("error", {
-        scheduleType: schedule.scheduleType,
-        triggeredWorkflows,
-        wasRecovered: true,
-        consecutiveErrors: schedule.consecutiveErrors ?? 0
-      });
-      console.error(`[Scheduler] Error recovering "${schedule.name}":`, err);
-    }
+    await executeSchedule(schedule, ["recovered"]);
   }
 }
 function calculateNextRun(schedule, fromTime = new Date) {
@@ -403,47 +394,33 @@ function getBackoffMs(consecutiveErrors) {
   const idx = Math.min(consecutiveErrors - 1, ERROR_BACKOFF_MS.length - 1);
   return ERROR_BACKOFF_MS[Math.max(0, idx)] ?? ERROR_BACKOFF_MS[0];
 }
-async function executeSchedule(schedule) {
-  schedule = renderScheduledTaskParams(schedule);
+async function executeSchedule(schedule, extraTags = []) {
+  let claimed = schedule;
   let triggeredWorkflows = false;
+  const wasRecovered = extraTags.includes("recovered");
   try {
-    ({ triggeredWorkflows } = await dispatchScheduleTarget(schedule));
-    const now = new Date().toISOString();
-    if (schedule.scheduleType === "one_time") {
-      await updateScheduledTask(schedule.id, {
-        lastRunAt: now,
-        nextRunAt: null,
-        enabled: false,
-        lastUpdatedAt: now,
-        consecutiveErrors: 0,
-        lastErrorAt: null,
-        lastErrorMessage: null
-      });
-      console.log(`[Scheduler] Executed one-time schedule "${schedule.name}", auto-disabled`);
-    } else {
-      const nextRun = calculateNextRun(schedule, new Date);
-      await updateScheduledTask(schedule.id, {
-        lastRunAt: now,
-        nextRunAt: nextRun,
-        lastUpdatedAt: now,
-        consecutiveErrors: 0,
-        lastErrorAt: null,
-        lastErrorMessage: null
-      });
-      console.log(`[Scheduler] Executed schedule "${schedule.name}", next run: ${nextRun}`);
-    }
+    const occurrence = await claimScheduleOccurrence(schedule, extraTags);
+    if (!occurrence)
+      return;
+    ({ schedule, claimed } = occurrence);
+    ({ triggeredWorkflows } = occurrence.dispatched ?? await dispatchScheduleTarget(schedule, extraTags));
+    await updateClaimedSchedule(claimed, {
+      consecutiveErrors: 0,
+      lastErrorAt: null,
+      lastErrorMessage: null
+    });
+    console.log(`[Scheduler] Executed schedule "${schedule.name}", next run: ${claimed.nextRunAt ?? "disabled"}`);
     telemetry.schedule("executed", {
       scheduleType: schedule.scheduleType,
       triggeredWorkflows,
-      wasRecovered: false
+      wasRecovered
     });
   } catch (err) {
     if (err instanceof AutomationNeedsSetupError) {
-      await advanceScheduleAfterNeedsSetup(schedule);
       telemetry.schedule("error", {
         scheduleType: schedule.scheduleType,
         triggeredWorkflows,
-        wasRecovered: false,
+        wasRecovered,
         consecutiveErrors: schedule.consecutiveErrors ?? 0
       });
       return;
@@ -469,26 +446,32 @@ async function executeSchedule(schedule) {
       updates.nextRunAt = new Date(now.getTime() + backoff).toISOString();
       console.log(`[Scheduler] Backing off "${schedule.name}" for ${backoff / 1000}s`);
     }
-    await updateScheduledTask(schedule.id, updates);
+    await updateClaimedSchedule(claimed, updates);
     telemetry.schedule("error", {
       scheduleType: schedule.scheduleType,
       triggeredWorkflows,
-      wasRecovered: false,
+      wasRecovered,
       consecutiveErrors: errorCount
     });
   }
 }
 function startScheduler(registry, intervalMs = 1e4, opts) {
-  if (schedulerInterval) {
+  if (schedulerRun) {
     console.log("[Scheduler] Already running");
     return;
   }
+  const run = {};
+  schedulerRun = run;
   executorRegistry = registry;
   console.log(`[Scheduler] Starting with ${intervalMs}ms polling interval`);
-  initDeferredTaskWaits().then(() => recoverMissedSchedules()).then(() => processSchedules()).catch((err) => console.error("[Scheduler] Recovery failed:", err));
-  schedulerInterval = setInterval(async () => {
+  initDeferredTaskWaits().then(() => schedulerRun === run ? recoverMissedSchedules() : undefined).catch((err) => console.error("[Scheduler] Recovery failed:", err)).then(async () => {
+    if (schedulerRun !== run)
+      return;
+    schedulerInterval = setInterval(() => {
+      processSchedules().catch((err) => console.error("[Scheduler] Poll failed:", err));
+    }, intervalMs);
     await processSchedules();
-  }, intervalMs);
+  }).catch((err) => console.error("[Scheduler] Poll failed:", err));
   ensure({
     id: "scheduler_started",
     flow: "api",
@@ -525,11 +508,11 @@ async function processSchedules() {
   }
 }
 function stopScheduler() {
+  schedulerRun = null;
   stopDeferredTaskWaits();
   if (schedulerInterval) {
     clearInterval(schedulerInterval);
     schedulerInterval = null;
-    isProcessing = false;
     console.log("[Scheduler] Stopped");
   }
 }

package/dist/{cli-phsxnkp6.js → cli-ryz8q8p1.js}

@@ -1,27 +1,27 @@
+import {
+  checkOpencodeCredentials
+} from "./cli-5my3bjsd.js";
 import {
   renderSteeringDelivery
-} from "./cli-xm87hzbw.js";
+} from "./cli-7fesa1ky.js";
 import {
   checkCodexCredentials,
   codexUserHome
-} from "./cli-e95cx1eb.js";
+} from "./cli-taym3dmg.js";
 import {
   checkClaudeManagedCredentials
-} from "./cli-6664w7y4.js";
+} from "./cli-wk0gjrn3.js";
 import {
   checkDevinCredentials
 } from "./cli-9b13ggd1.js";
-import {
-  checkOpencodeCredentials
-} from "./cli-5my3bjsd.js";
 import {
   renderMemoriesPrompt,
   resolveScriptsOnlyMode,
   writeSkillsToFilesystem
-} from "./cli-yb9qhqam.js";
+} from "./cli-3mh119qv.js";
 import {
   checkClaudeCredentials
-} from "./cli-7smrsr25.js";
+} from "./cli-zthatyrx.js";
 import {
   MAX_RATE_LIMIT_RESET_MS,
   isCodexCreditsExhaustedMessage,
@@ -34,7 +34,7 @@ import {
 } from "./cli-s25avqg9.js";
 import {
   validateJsonSchema
-} from "./cli-6pqcb4q0.js";
+} from "./cli-rnsr8asm.js";
 import {
   authJsonToCredentialSelection,
   credentialsToAuthJson,
@@ -61,7 +61,7 @@ import {
   syncProfileFilesToServer,
   writeIdentityBaselines,
   writeProfileFileFromDb
-} from "./cli-zvz62chv.js";
+} from "./cli-a45d5v9b.js";
 import {
   ensure,
   initOtel,
@@ -71,11 +71,11 @@ import {
   startSpan,
   withSpan,
   withSpanContext
-} from "./cli-d8ftsp62.js";
+} from "./cli-kt7wevqh.js";
 import {
   init_task_attachment_links,
   taskAttachmentFetchCommand
-} from "./cli-9d8ntetj.js";
+} from "./cli-2658f6at.js";
 import {
   ProviderNameSchema,
   initTelemetry,
@@ -83,7 +83,11 @@ import {
   init_types,
   resolveTaskModelSelection,
   telemetry
-} from "./cli-yab68w40.js";
+} from "./cli-qp69dd5d.js";
+import {
+  init_credentials,
+  resolveCredentialPools
+} from "./cli-c2mk1kgf.js";
 import {
   generateDefaultClaudeMd,
   generateDefaultIdentityMd,
@@ -93,7 +97,7 @@ import {
   init_base_prompt,
   init_defaults,
   init_templates
-} from "./cli-08b07b4r.js";
+} from "./cli-hmyynq9b.js";
 import {
   configureHttpResolver,
   init_resolver,
@@ -102,15 +106,11 @@ import {
   interpolate,
   isSteeringEnabled,
   resolveTemplateAsync
-} from "./cli-3apbzgyk.js";
+} from "./cli-n75jt793.js";
 import {
   getMcpBaseUrl,
   init_constants
-} from "./cli-e29gmdmw.js";
-import {
-  init_credentials,
-  resolveCredentialPools
-} from "./cli-c2mk1kgf.js";
+} from "./cli-dv6cdjs2.js";
 import {
   init_secret_scrubber,
   scrubSecrets
@@ -151,19 +151,19 @@ async function materializeCodexAuthJson(_slot, creds, deps = {}) {
 async function createProviderAdapter(provider) {
   switch (provider) {
     case "claude": {
-      const { ClaudeAdapter } = await import("./claude-adapter-3qpa9w0j.js");
+      const { ClaudeAdapter } = await import("./claude-adapter-cjegjbje.js");
       return new ClaudeAdapter;
     }
     case "pi": {
-      const { PiMonoAdapter } = await import("./pi-mono-adapter-zvshk5cj.js");
+      const { PiMonoAdapter } = await import("./pi-mono-adapter-4s2bbkgq.js");
       return new PiMonoAdapter;
     }
     case "codex": {
-      const { CodexAdapter } = await import("./codex-adapter-8meawydj.js");
+      const { CodexAdapter } = await import("./codex-adapter-rn3aq7jm.js");
       return new CodexAdapter;
     }
     case "claude-managed": {
-      const { ClaudeManagedAdapter } = await import("./claude-managed-adapter-qvsmh6mv.js");
+      const { ClaudeManagedAdapter } = await import("./claude-managed-adapter-p3ts5m9m.js");
       return new ClaudeManagedAdapter;
     }
     case "devin": {
@@ -175,7 +175,7 @@ async function createProviderAdapter(provider) {
       return new OpencodeAdapter;
     }
     case "acp": {
-      const { ACPAdapter } = await import("./acp-adapter-4jncb126.js");
+      const { ACPAdapter } = await import("./acp-adapter-d5mzggyk.js");
       return new ACPAdapter;
     }
     default:
@@ -588,7 +588,7 @@ var CREDENTIAL_PROVIDER_CHECKERS = {
   devin: (env) => checkDevinCredentials(env),
   opencode: (env, opts) => checkOpencodeCredentials(env, opts),
   pi: async (env, opts) => {
-    const { checkPiMonoCredentials } = await import("./pi-mono-adapter-zvshk5cj.js");
+    const { checkPiMonoCredentials } = await import("./pi-mono-adapter-4s2bbkgq.js");
     return checkPiMonoCredentials(env, opts);
   },
   acp: () => ({ ready: true, missing: [], satisfiedBy: "sdk-delegated" })
@@ -832,17 +832,6 @@ async function sendCredStatusReport(apiUrl, apiKey, agentId, runtimeInstanceId,
     throw new Error(`credential-status report failed: ${res.status} ${body}`.trim());
   }
 }
-async function reportCredStatus(apiUrl, apiKey, agentId, runtimeInstanceId, credStatus) {
-  try {
-    await sendCredStatusReport(apiUrl, apiKey, agentId, runtimeInstanceId, {
-      ready: credStatus.ready,
-      missing: credStatus.missing,
-      credStatus
-    });
-  } catch (err) {
-    console.warn(`[cred-status] POST failed (non-fatal): ${err}`);
-  }
-}
 async function reportLatestModel(apiUrl, apiKey, agentId, latestModel) {
   try {
     await fetch(`${apiUrl}/api/agents/${encodeURIComponent(agentId)}/credential-status`, {
@@ -891,6 +880,43 @@ function buildLatestModelReport(opts) {
   };
 }
 
+// src/commands/credential-refresh.ts
+var CREDENTIAL_RETRY_INTERVAL_MS = 30000;
+var BEDROCK_REFRESH_INTERVAL_MS = 5 * 60 * 1000;
+async function refreshCredentialStatus(api, state, harnessProvider, env, now = Date.now()) {
+  if (isCredCheckDisabled(env) || state.inFlight)
+    return;
+  const providerChanged = state.harnessProvider !== harnessProvider;
+  const retryDue = state.ready !== true && now - state.lastRefreshAt >= CREDENTIAL_RETRY_INTERVAL_MS;
+  if (!providerChanged && !retryDue && !shouldRefreshBedrockStatus({
+    harnessProvider,
+    env,
+    lastRefreshAt: state.lastRefreshAt,
+    now,
+    intervalMs: BEDROCK_REFRESH_INTERVAL_MS
+  })) {
+    return;
+  }
+  state.harnessProvider = harnessProvider;
+  state.lastRefreshAt = now;
+  state.ready = null;
+  state.inFlight = true;
+  try {
+    const snapshot = await buildCredStatusReport(harnessProvider, { ...env }, {}, "post_task");
+    if (state.harnessProvider !== harnessProvider)
+      return;
+    await sendCredStatusReport(api.apiUrl, api.apiKey, api.agentId, api.runtimeInstanceId, {
+      ready: snapshot.ready,
+      missing: snapshot.missing,
+      credStatus: snapshot
+    });
+    if (state.harnessProvider === harnessProvider)
+      state.ready = snapshot.ready;
+  } finally {
+    state.inFlight = false;
+  }
+}
+
 // src/commands/credential-wait.ts
 var EX_CONFIG = 78;
 
@@ -3973,13 +3999,16 @@ ${additionalSystemPrompt}` : basePrompt;
   };
   const cancelledSignaled = new Set;
   const steeringDispatchState = isSteeringEnabled() ? createSteeringDispatchState() : null;
-  let cachedCredHarnessProvider = null;
+  const credentialRefreshState = {
+    harnessProvider: null,
+    ready: null,
+    lastRefreshAt: 0,
+    inFlight: false
+  };
   let lastHarnessReconcileAt = 0;
   const HARNESS_RECONCILE_INTERVAL_MS = 1e4;
   let lastServerCapsRefreshAt = 0;
   const SERVER_CAPS_REFRESH_INTERVAL_MS = 300000;
-  let lastBedrockRefreshAt = 0;
-  const BEDROCK_REFRESH_INTERVAL_MS = 5 * 60 * 1000;
   const runtimeInstanceId = crypto.randomUUID();
   process.env.SWARM_RUNTIME_INSTANCE_ID = runtimeInstanceId;
   const apiConfig = { apiUrl, apiKey, agentId, runtimeInstanceId };
@@ -4001,7 +4030,7 @@ ${additionalSystemPrompt}` : basePrompt;
 
 ${additionalSystemPrompt}` : basePrompt;
         promptRebuiltForProvider = true;
-        cachedCredHarnessProvider = null;
+        credentialRefreshState.harnessProvider = null;
         agentVisibleChanged = true;
         console.log(`[${role}] [harness] Swapped to ${resolvedProvider} (basePrompt rebuilt: ${basePrompt.length} chars)`);
       } catch (err) {
@@ -4094,7 +4123,6 @@ ${additionalSystemPrompt}` : basePrompt;
     agentId,
     alreadyProvisioned: agentFsProvisioned
   });
-  cachedCredHarnessProvider = state.harnessProvider;
   if (isCredCheckDisabled(process.env)) {
     console.log(`[${role}] CRED_CHECK_DISABLE=1, skipping credential checks`);
   } else {
@@ -4158,6 +4186,9 @@ ${additionalSystemPrompt}` : basePrompt;
         label: "credential readiness report",
         log: (line) => console.warn(`[${role}] ${line}`)
       });
+      credentialRefreshState.harnessProvider = state.harnessProvider;
+      credentialRefreshState.ready = bootCredSnapshot?.ready ?? true;
+      credentialRefreshState.lastRefreshAt = Date.now();
     } catch (error) {
       console.error(`[${role}] Failed to report credential readiness after recovery: ${error}`);
       process.exit(1);
@@ -4566,22 +4597,7 @@ ${additionalSystemPrompt}` : basePrompt;
         console.warn(`[${role}] [harness] Reconcile fetch failed (non-fatal): ${err}`);
       }
     }
-    if (!isCredCheckDisabled(process.env)) {
-      const currentHarness = state.harnessProvider;
-      if (currentHarness !== cachedCredHarnessProvider) {
-        cachedCredHarnessProvider = currentHarness;
-        buildCredStatusReport(currentHarness, process.env, {}, "post_task").then((snap) => reportCredStatus(apiUrl, apiKey, agentId, runtimeInstanceId, snap)).catch((err) => console.warn(`[${role}] cred_status post_task report failed (non-fatal): ${err}`));
-      } else if (shouldRefreshBedrockStatus({
-        harnessProvider: currentHarness,
-        env: process.env,
-        lastRefreshAt: lastBedrockRefreshAt,
-        now: Date.now(),
-        intervalMs: BEDROCK_REFRESH_INTERVAL_MS
-      })) {
-        lastBedrockRefreshAt = Date.now();
-        buildCredStatusReport(currentHarness, process.env, {}, "post_task").then((snap) => reportCredStatus(apiUrl, apiKey, agentId, runtimeInstanceId, snap)).catch((err) => console.warn(`[${role}] bedrock enumeration refresh failed (non-fatal): ${err}`));
-      }
-    }
+    refreshCredentialStatus(apiConfig, credentialRefreshState, state.harnessProvider, process.env).catch((err) => console.warn(`[${role}] cred_status post_task refresh failed (non-fatal): ${err}`));
     const now = Date.now();
     for (const [taskId, task] of state.activeTasks) {
       if (vcsDetectedTasks.has(taskId))

package/dist/{cli-e95cx1eb.js → cli-taym3dmg.js}

@@ -1,9 +1,9 @@
-import {
-  createSwarmEventHandler
-} from "./cli-hsxj0yar.js";
 import {
   resolveCodexPrompt
 } from "./cli-r94z9p1z.js";
+import {
+  createSwarmEventHandler
+} from "./cli-hsxj0yar.js";
 import {
   readPkgVersion
 } from "./cli-2djtr51b.js";
@@ -11,25 +11,25 @@ import {
   SessionErrorTracker,
   buildOtelTraceparentEnv
 } from "./cli-b5b30yzk.js";
-import {
-  summarizeSession
-} from "./cli-jecc01cb.js";
 import {
   CTX_MODE_NUDGE_EVERY
 } from "./cli-zm7njwzd.js";
+import {
+  summarizeSession
+} from "./cli-dyx0237s.js";
 import {
   CONTEXT_FORMULA,
   clampContextPercent,
   computeContextUsedUnified
 } from "./cli-s25avqg9.js";
+import {
+  applyReasoningEffort
+} from "./cli-4yc5d8fk.js";
 import {
   buildRatingsFromLlm,
   fetchRetrievalsForTask,
   postRatings
 } from "./cli-xvkmedgn.js";
-import {
-  applyReasoningEffort
-} from "./cli-4yc5d8fk.js";
 import {
   swarmRuntimeInstanceId
 } from "./cli-07jd68a1.js";
@@ -49,7 +49,7 @@ import {
 import {
   init_package,
   package_default
-} from "./cli-kjwt6hdf.js";
+} from "./cli-gm0fhz13.js";
 import {
   init_secret_scrubber,
   scrubSecrets