@integrity-labs/agt-cli 0.28.523 → 0.28.524

package/dist/bin/agt.js

@@ -40,7 +40,7 @@ import {
   success,
   table,
   warn
-} from "../chunk-HERASX7X.js";
+} from "../chunk-QYQR4BWM.js";
 import {
   AnchorSessionClient,
   CHANNEL_REGISTRY,
@@ -4834,7 +4834,7 @@ import { execFileSync, execSync } from "child_process";
 import { existsSync as existsSync10, realpathSync as realpathSync2 } from "fs";
 import chalk18 from "chalk";
 import ora16 from "ora";
-var cliVersion = true ? "0.28.523" : "dev";
+var cliVersion = true ? "0.28.524" : "dev";
 async function fetchLatestVersion() {
   const host2 = getHost();
   if (!host2) return null;
@@ -6006,7 +6006,7 @@ function handleError(err) {
 }
 
 // src/bin/agt.ts
-var cliVersion2 = true ? "0.28.523" : "dev";
+var cliVersion2 = true ? "0.28.524" : "dev";
 var program = new Command();
 program.name("agt").description("Augmented CLI \u2014 agent provisioning and management").version(cliVersion2).option("--json", "Emit machine-readable JSON output (suppress spinners and colors)").option("--skip-update-check", "Skip the automatic update check on startup");
 program.hook("preAction", async (thisCommand, actionCommand) => {

package/dist/{chunk-HERASX7X.js → chunk-QYQR4BWM.js}

@@ -5317,7 +5317,7 @@ function exchangeFailureKind(err) {
 }
 
 // src/lib/api-client.ts
-var agtCliVersion = true ? "0.28.523" : "dev";
+var agtCliVersion = true ? "0.28.524" : "dev";
 var lastConfigHash = null;
 function setConfigHash(hash) {
   lastConfigHash = hash && hash.length > 0 ? hash : null;
@@ -8629,4 +8629,4 @@ export {
   managerInstallSystemUnitCommand,
   managerUninstallSystemUnitCommand
 };
-//# sourceMappingURL=chunk-HERASX7X.js.map
+//# sourceMappingURL=chunk-QYQR4BWM.js.map

package/dist/lib/manager-worker.js

@@ -53,7 +53,7 @@ import {
   safeWriteJsonAtomic,
   setConfigHash,
   tripClass
-} from "../chunk-HERASX7X.js";
+} from "../chunk-QYQR4BWM.js";
 import {
   getProjectDir as getProjectDir2,
   getReadyTasks,
@@ -9567,6 +9567,7 @@ var RESTART_DEFER_RECHECK_MS = 6e4;
 var DEFER_LOG_THROTTLE_MS = 6e5;
 var deferLogThrottle = /* @__PURE__ */ new Map();
 var lastInboundMs = /* @__PURE__ */ new Map();
+var pendingDayRolloverReset = /* @__PURE__ */ new Set();
 var consecutiveWedgeCycles = /* @__PURE__ */ new Map();
 var wedgeExemptionLogged = /* @__PURE__ */ new Set();
 var wedgeRestartsByCard = /* @__PURE__ */ new Map();
@@ -9578,6 +9579,66 @@ function inboundAgeSecondsFor(codeName) {
   if (ts === void 0) return null;
   return Math.max(0, Math.floor((Date.now() - ts) / 1e3));
 }
+function decideDayRolloverAction(i) {
+  if (!i.staleForToday || !i.sessionHealthy || !i.hasCurrent) return "none";
+  if (i.idle) return "defer-idle";
+  return i.overdueMin >= i.graceMin ? "force-reset" : "busy-wait";
+}
+function classifyLazyDayRolloverReset(i) {
+  if (!i.flagged) return "skip";
+  if (!i.sessionHealthy) return "clear-stale";
+  if (!i.staleForToday) return "clear-stale";
+  if (!i.hasCurrent) return "skip";
+  return i.idle ? "reset" : "skip";
+}
+function resolveEffectiveAgentTimezone(inputs) {
+  const orgTierTz = cachedMaintenanceWindow?.timezone ?? null;
+  const ownTzEffective = isAgentTimezoneOverrideExpired(inputs.agentTimezoneExpiresAt) ? null : inputs.agentTimezone;
+  if (isUnsetTimezone(ownTzEffective) && isUnsetTimezone(inputs.teamTimezone) && isUnsetTimezone(orgTierTz)) {
+    return void 0;
+  }
+  return resolveAgentTimezone(
+    ownTzEffective,
+    inputs.teamTimezone,
+    orgTierTz,
+    inputs.agentTimezoneExpiresAt
+  );
+}
+function cachedAgentTimezoneFor(codeName) {
+  const inputs = agentRestartTimezoneInputs.get(codeName);
+  if (!inputs) return void 0;
+  return resolveEffectiveAgentTimezone({
+    agentTimezone: inputs.agentTimezone,
+    teamTimezone: inputs.teamTimezone,
+    agentTimezoneExpiresAt: inputs.agentTimezoneExpiresAt
+  });
+}
+function performLazyDayRolloverReset(codeName, agentTimezone) {
+  const flagged = pendingDayRolloverReset.has(codeName);
+  const sessionHealthy = flagged && isSessionHealthy(codeName);
+  const staleForToday = flagged ? isStaleForToday(codeName, /* @__PURE__ */ new Date(), agentTimezone ?? void 0) : false;
+  const current = flagged && sessionHealthy && staleForToday ? peekCurrentSession(codeName) : null;
+  const outcome = classifyLazyDayRolloverReset({
+    flagged,
+    staleForToday,
+    sessionHealthy,
+    hasCurrent: current !== null,
+    idle: current ? isAgentIdle(getProjectDir(codeName), current.sessionId) : false
+  });
+  if (outcome === "clear-stale") {
+    pendingDayRolloverReset.delete(codeName);
+    return false;
+  }
+  if (outcome === "skip" || !current) return false;
+  log(
+    `[persistent-session] Day rollover for '${codeName}' (yesterday=${current.date}) \u2014 first real trigger after an idle rollover; minting a fresh session now (deferred boot, paid alongside real work) [ENG-8461]`
+  );
+  stopPersistentSessionAndForgetMcpBaseline(codeName, "day-rollover");
+  agentState.persistentSessionAgents.delete(codeName);
+  rotatePaneLogForDayRollover(codeName, log, agentTimezone);
+  pendingDayRolloverReset.delete(codeName);
+  return true;
+}
 function paneLogAgeSecondsFor(codeName) {
   try {
     const mtimeMs = statSync6(paneLogPath(codeName)).mtimeMs;
@@ -10106,7 +10167,7 @@ var agentRestartTimezoneInputs = /* @__PURE__ */ new Map();
 var lastVersionCheckAt = 0;
 var VERSION_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
 var lastResponsivenessProbeAt = 0;
-var agtCliVersion = true ? "0.28.523" : "dev";
+var agtCliVersion = true ? "0.28.524" : "dev";
 function resolveBrewPath(execFileSync2) {
   try {
     const out = execFileSync2("which", ["brew"], { timeout: 5e3 }).toString().trim();
@@ -14505,14 +14566,13 @@ async function ensurePersistentSession(agent, tasks, boardItems, refreshData) {
     const ownTz = typeof ownTzRaw === "string" && ownTzRaw.trim() !== "" ? ownTzRaw.trim() : null;
     const tz = teamSettingsForTz?.["timezone"];
     const teamTz = typeof tz === "string" && tz.trim() !== "" ? tz.trim() : null;
-    const orgTierTz = cachedMaintenanceWindow?.timezone ?? null;
     const ownTzExpiresAtRaw = refreshData.agent?.timezone_expires_at;
     const ownTzExpiresAt = typeof ownTzExpiresAtRaw === "string" && ownTzExpiresAtRaw.trim() !== "" ? ownTzExpiresAtRaw : null;
-    const ownTzEffective = isAgentTimezoneOverrideExpired(ownTzExpiresAt) ? null : ownTz;
-    if (isUnsetTimezone(ownTzEffective) && isUnsetTimezone(teamTz) && isUnsetTimezone(orgTierTz)) {
-      return void 0;
-    }
-    return resolveAgentTimezone(ownTzEffective, teamTz, orgTierTz, ownTzExpiresAt);
+    return resolveEffectiveAgentTimezone({
+      agentTimezone: ownTz,
+      teamTimezone: teamTz,
+      agentTimezoneExpiresAt: ownTzExpiresAt
+    });
   })();
   const frameworkId = agentFrameworkCache.get(codeName) ?? DEFAULT_FRAMEWORK;
   if (frameworkId === "opencode") {
@@ -14649,35 +14709,40 @@ async function ensurePersistentSession(agent, tasks, boardItems, refreshData) {
     agentState.persistentSessionAgents.delete(codeName);
     restartTrigger = "auth-tuple";
   }
-  if (isStaleForToday(codeName, /* @__PURE__ */ new Date(), agentTimezone) && isSessionHealthy(codeName)) {
-    const current = peekCurrentSession(codeName);
-    if (current) {
-      const idle = isAgentIdle(projectDir, current.sessionId);
-      if (idle) {
-        log(
-          `[persistent-session] Day rollover for '${codeName}' (yesterday=${current.date}) \u2014 agent idle, restarting to mint fresh session`
-        );
-        stopPersistentSessionAndForgetMcpBaseline(codeName, "day-rollover");
-        agentState.persistentSessionAgents.delete(codeName);
-        restartTrigger = "day-rollover";
-      } else {
-        const overdueMin = minutesSinceLocalMidnight(/* @__PURE__ */ new Date(), agentTimezone);
-        if (overdueMin >= DAY_ROLLOVER_FORCE_GRACE_MIN) {
-          log(
-            `[persistent-session] Day rollover FORCED for '${codeName}' (yesterday=${current.date}) \u2014 agent busy-blocked ${overdueMin}m past the day boundary (grace ${DAY_ROLLOVER_FORCE_GRACE_MIN}m), restarting anyway to reset context`
-          );
-          stopPersistentSessionAndForgetMcpBaseline(codeName, "day-rollover");
-          agentState.persistentSessionAgents.delete(codeName);
-          restartTrigger = "day-rollover";
-          dayRolloverForced = true;
-        } else {
-          log(
-            `[persistent-session] Day rollover for '${codeName}' deferred \u2014 agent still active on session ${current.sessionId} (${overdueMin}m past boundary, will force at ${DAY_ROLLOVER_FORCE_GRACE_MIN}m)`
-          );
-          dayRolloverDeferred = true;
-        }
-      }
+  const staleForToday = isStaleForToday(codeName, /* @__PURE__ */ new Date(), agentTimezone);
+  if (!staleForToday) pendingDayRolloverReset.delete(codeName);
+  const rolloverSessionHealthy = isSessionHealthy(codeName);
+  const rolloverCurrent = staleForToday && rolloverSessionHealthy ? peekCurrentSession(codeName) : null;
+  const overdueMin = rolloverCurrent ? minutesSinceLocalMidnight(/* @__PURE__ */ new Date(), agentTimezone) : 0;
+  const rolloverDecision = decideDayRolloverAction({
+    staleForToday,
+    sessionHealthy: rolloverSessionHealthy,
+    hasCurrent: rolloverCurrent !== null,
+    idle: rolloverCurrent ? isAgentIdle(projectDir, rolloverCurrent.sessionId) : false,
+    overdueMin,
+    graceMin: DAY_ROLLOVER_FORCE_GRACE_MIN
+  });
+  if (rolloverDecision === "defer-idle" && rolloverCurrent) {
+    if (!pendingDayRolloverReset.has(codeName)) {
+      pendingDayRolloverReset.add(codeName);
+      log(
+        `[persistent-session] Day rollover for '${codeName}' (yesterday=${rolloverCurrent.date}) \u2014 agent idle; keeping the warm session and deferring the fresh-session mint to the first real trigger (no boot booked as utilization) [ENG-8461]`
+      );
     }
+  } else if (rolloverDecision === "force-reset" && rolloverCurrent) {
+    log(
+      `[persistent-session] Day rollover FORCED for '${codeName}' (yesterday=${rolloverCurrent.date}) \u2014 agent busy-blocked ${overdueMin}m past the day boundary (grace ${DAY_ROLLOVER_FORCE_GRACE_MIN}m), restarting anyway to reset context`
+    );
+    stopPersistentSessionAndForgetMcpBaseline(codeName, "day-rollover");
+    agentState.persistentSessionAgents.delete(codeName);
+    pendingDayRolloverReset.delete(codeName);
+    restartTrigger = "day-rollover";
+    dayRolloverForced = true;
+  } else if (rolloverDecision === "busy-wait" && rolloverCurrent) {
+    log(
+      `[persistent-session] Day rollover for '${codeName}' deferred \u2014 agent still active on session ${rolloverCurrent.sessionId} (${overdueMin}m past boundary, will force at ${DAY_ROLLOVER_FORCE_GRACE_MIN}m)`
+    );
+    dayRolloverDeferred = true;
   }
   if (restartTrigger === "day-rollover") {
     rotatePaneLogForDayRollover(codeName, log, agentTimezone);
@@ -14897,7 +14962,15 @@ ${truncateForLog(ctx.tail)}` : `; pane_tail_hash=sha256:${createHash16("sha256")
         deferReadyForUsageCap = true;
       }
     }
-    for (const task of deferReadyForUsageCap ? [] : ready) {
+    let deferReadyForRollover = false;
+    if (!deferReadyForUsageCap && ready.length > 0 && performLazyDayRolloverReset(codeName, agentTimezone)) {
+      restartTrigger = "day-rollover";
+      deferReadyForRollover = true;
+      log(
+        `[persistent-session] Deferring ${ready.length} ready task(s) for '${codeName}' \u2014 minting a fresh session after an idle day-rollover; schedule NOT advanced, task fires on the fresh session next tick [ENG-8461]`
+      );
+    }
+    for (const task of deferReadyForUsageCap || deferReadyForRollover ? [] : ready) {
       if (KANBAN_WORK_TEMPLATES.has(task.templateId)) {
         const updated = markTaskFired(codeName, task.taskId, "ok");
         claudeSchedulerStates.set(codeName, updated);
@@ -15485,6 +15558,12 @@ async function processDirectChatMessage(agent, msg) {
     await processDirectChatMessageOpencode(agent, msg);
     return;
   }
+  if (performLazyDayRolloverReset(agent.codeName, cachedAgentTimezoneFor(agent.codeName))) {
+    log(
+      `[direct-chat] Reset '${agent.codeName}' to a fresh session on first inbound after an idle day-rollover (msg=${msg.id}) \u2014 leaving pending for durable replay on the fresh session [ENG-8461]`
+    );
+    return;
+  }
   if (isSessionHealthy(agent.codeName)) {
     const useDoorbell = hostFlagStore().getBoolean("direct-chat-doorbell") || isolationMode(agent.codeName) === "docker";
     if (useDoorbell) {
@@ -16599,10 +16678,12 @@ export {
   DAY_ROLLOVER_FORCE_GRACE_MIN,
   applyRestartAcks,
   cancelKanbanNoticeOnDrain,
+  classifyLazyDayRolloverReset,
   claudeCodeUpgradeMarkerPath,
   claudeCodeUpgradeThrottled,
   claudeManagedSettingsPath,
   dashboardRestartBreakerReason,
+  decideDayRolloverAction,
   ensureClaudeManagedSettings,
   extractCharterSlackPeers,
   extractCharterTelegramPeers,