fix: surface an unbilled run, and clamp the google-docs page cap

[waleedlatif1]

Two places where a failure is reported as something smaller than it is.

A run that is never billed logs as a notification problem

lib/logs/execution/logger.ts:1389

} catch (e) {
  // Safety net: if a step above threw BEFORE the single record call, ensure
  // the run is still billed. Reconciliation is idempotent...
  try {
    await this.recordExecutionUsage(...)
  } catch {}
  execLog.warn('Usage threshold notification check failed (non-fatal)', { error: e })
}

The comment documents the safety net, not the bare catch {} inside it.

The outer try covers a user lookup, recordExecutionUsage, and the threshold-email calls. With a degraded database the lookup throws before the record call, the safety-net re-record hits the same degraded database and is swallowed, and the run is never billed. The only line emitted says the notification check failed and was non-fatal — true of the outer failure, badly wrong about the inner one.

That is the shape that keeps a revenue-losing incident out of alerting: the log asserts the opposite of what happened.

Now logs at error with the execution and workflow ids, saying the run may be unbilled. The outer warn still covers the email path it was written for.

google-docs can ask Drive for a negative page

// google-slides.ts:301
/** Last-page precision: never ask Drive for more files than the cap still allows. */
const remaining = maxDocs > 0 ? Math.max(0, maxDocs - previouslyFetched) : 0

// google-docs.ts:307  — no clamp
const remaining = maxDocs > 0 ? maxDocs - previouslyFetched : 0

Both then run:

if (maxDocs > 0 && documents.length > remaining) documents = documents.slice(0, remaining)

A negative remaining makes that guard true for any non-empty page, and slice counts a negative end from the end — so it keeps the leading documents and drops the trailing ones, where the cap says to keep none. The wrong subset, silently, with slicedSome set.

Reachable when maxDocs is lowered while a sync cursor persists. google-drive guards the same case a different way (an early return when previouslyFetched >= maxFiles); google-docs had neither, and its google-slides twin carries the fix under a comment marking it deliberate — it just never propagated.

Scope

The logging change is observability only. The clamp changes behavior exactly in the case that is currently wrong.

Testing

1653 tests passing across lib/logs and connectors; bun run type-check clean.

[vercel]

The latest updates on your projects. Learn more about Vercel for GitHub.

1 Skipped Deployment

Project	Deployment	Actions	Updated (UTC)
docs	Skipped		Aug 24, 2026 1:59am

[cursor]

PR Summary

Medium Risk
Touches execution usage recording observability (billing-adjacent) and Google Docs sync capping. Logging is observability-only; the clamp only changes the previously incorrect over-cap case.

Overview
Fixes two cases where failures were under-reported or produced the wrong result.

When the billing safety net in completeWorkflowExecution also fails, it now logs an error that the run may be unbilled (with execution and workflow ids) instead of a silent catch {} that only left a non-fatal notification warning.

Google Docs listing clamps remaining with Math.max(0, …) so a lowered maxDocs against a persisted cursor cannot go negative. Negative remaining made slice keep the wrong subset of a page.

^{Reviewed by Cursor Bugbot for commit 9c2a46a. Configure here.}

[greptile-apps]

Greptile Summary

The PR fixes two underreported failure cases.

• Clamps the Google Docs pagination remainder to zero when a persisted sync count exceeds a lowered document cap.
• Emits an execution-scoped error when the final usage-recording safety net fails, while retaining the existing non-fatal notification warning.

Confidence Score: 5/5

The PR appears safe to merge, with both changes narrowly correcting the described pagination and observability behavior.

The connector clamp terminates capped pagination without exposing deletion reconciliation to a partial sliced listing, and the new billing diagnostic preserves structured identifiers without changing execution control flow.

Important Files Changed

Filename	Overview
apps/sim/connectors/google-docs/google-docs.ts	Clamps the remaining document allowance so an exhausted cap returns no documents instead of applying negative slice semantics.
apps/sim/lib/logs/execution/logger.ts	Adds a throw-safe, execution-scoped error diagnostic when the fallback billing record attempt fails.

_{Reviews (1): Last reviewed commit: "fix: surface an unbilled run, and clamp ..." | Re-trigger Greptile}

[cursor]

Cursor Bugbot has reviewed your changes using high effort and found 1 potential issue.

^{❌ Bugbot Autofix is OFF. To automatically fix reported issues with cloud agents, enable autofix in the Cursor dashboard.}

^{Reviewed by Cursor Bugbot for commit 9c2a46a. Configure here.}

[cursor]

Safety-net error log is unreachable dead code

Medium Severity

The new catch (recordError) block and its execLog.error message are unreachable for the described failure scenario. recordExecutionUsage wraps its entire body in an internal try/catch (line 1789) that swallows all errors and only logs via statsLog.error — it never throws to its caller. When the database is degraded, the safety-net call silently returns 0 and the catch (recordError) never fires. The only log emitted remains the misleading "non-fatal" warning at line 1412, so unbilled runs are not actually surfaced at error level as intended.

Additional Locations (1)

• apps/sim/lib/logs/execution/logger.ts#L1788-L1802

 

^{Reviewed by Cursor Bugbot for commit 9c2a46a. Configure here.}