fix(pi): budget Babysit against the run's real deadline

Three fixes that each needed to land a level below where the symptom showed.

Execution deadline. Babysit planned its wait loop against
`getMaxExecutionTimeout()`, which unconditionally returns the enterprise
async ceiling (90 min) with no regard for the run's plan or sync/async mode
— the sync ceiling is 300s on free, 3000s on pro. A synchronously triggered
run was therefore killed mid-loop with the PR already opened, its review
comments already posted, and none of the rounds/stopReason outputs produced.

Rather than thread a numeric deadline through ExecutionContext — five entry
points that would each have to remember it, and nothing to catch the one that
forgot — `createTimeoutAbortController` now records the deadline against the
signal it creates, and `getRemainingExecutionMs(signal)` reads it back. The
number cannot disagree with the timer that enforces it, because both are
established in the one place the timeout exists, and every entry point
already hands the executor that signal. `undefined` means unknown, not
unlimited: Babysit keeps the old ceiling as its fallback for an untimed run.

Job logs. The executor caps a response at 10 MB and throws rather than
truncating, so a verbose CI job produced no diagnostic at all — and GitHub
Actions reports null title/summary on every check run, leaving the agent a
bare URL it has no tool to follow. The tool now sends `Range: bytes=-N` so
the storage host returns only the tail. Since a suffix range is a request and
not a guarantee, a 200 still takes the local slice.

That made the old output dishonest, so the contract changed while the tool is
still new and has one consumer: `totalCharacters` (which a ranged read cannot
know) is replaced by `totalBytes`, sourced from the `Content-Range` total and
null when unreported. A ranged body is trimmed at its first line break, since
the byte window cuts mid-line and can split a multi-byte character.

Generated docs. `github.mdx` was missing the `repo_full_name` the PR reader
now returns, and regenerating deleted the head/base rows instead of adding it:
`scripts/generate-docs.ts` only expands a spread at depth 0 of a const, and
`PR_BRANCH_REF_OUTPUT` spread inline under `properties`. Restructured into a
named properties const in types.ts, next to the shapes it belongs with, which
the generator resolves the same way it already resolves BRANCH_REF_OUTPUT.

Only the github.mdx hunk is committed. The generator is lossy elsewhere —
it drops 126 lines of trigger configuration from jira.mdx — which is
pre-existing drift for whoever owns that surface, not this branch.

Author: icecrasher321

apps/docs/content/docs/en/integrations/github.mdx

@@ -59,10 +59,12 @@ Fetch PR details including diff and files changed
 |   ↳ `label` | string | Branch label \(owner:branch\) |
 |   ↳ `ref` | string | Branch name |
 |   ↳ `sha` | string | Commit SHA |
+|   ↳ `repo_full_name` | string | Full name \(owner/repo\) of the branch's repository |
 | `base` | object | Branch reference info |
 |   ↳ `label` | string | Branch label \(owner:branch\) |
 |   ↳ `ref` | string | Branch name |
 |   ↳ `sha` | string | Commit SHA |
+|   ↳ `repo_full_name` | string | Full name \(owner/repo\) of the branch's repository |
 | `id` | number | Pull request ID |
 | `number` | number | Pull request number |
 | `title` | string | PR title |

apps/sim/executor/handlers/pi/cloud-backend.test.ts

@@ -37,6 +37,7 @@ vi.mock('@/executor/handlers/pi/keys', () => ({
 }))
 vi.mock('@/executor/handlers/pi/context', () => ({ buildPiPrompt: () => 'PROMPT' }))
 
+import { createTimeoutAbortController } from '@/lib/core/execution-limits'
 import type { PiCloudRunParams } from '@/executor/handlers/pi/backend'
 import { runCloudPi } from '@/executor/handlers/pi/cloud-backend'
 
@@ -288,6 +289,25 @@ describe('runCloudPi', () => {
     })
   })
 
+  // Babysit spends this budget sitting in waits, so it has to reflect the deadline the
+  // platform will actually enforce. Planning against the enterprise-async ceiling meant a
+  // sync run was killed mid-loop with the PR opened and its review comments posted.
+  it('budgets Babysit against the run signal deadline, not the platform maximum', async () => {
+    const controller = createTimeoutAbortController(4 * 60 * 1000)
+
+    await runCloudPi(
+      baseParams({
+        babysit: { maxRounds: 4, reviewMentions: ['@greptile'] },
+      }),
+      { onEvent: vi.fn(), signal: controller.signal }
+    )
+
+    const budget = mockRunBabysit.mock.calls[0][0].executionBudgetMs
+    expect(budget).toBeGreaterThan(0)
+    expect(budget).toBeLessThanOrEqual(4 * 60 * 1000)
+    controller.cleanup()
+  })
+
   it('skips the PR when nothing was pushed', async () => {
     mockRun.mockImplementation((command: string) => {
       if (command.includes('git clone')) {

apps/sim/executor/handlers/pi/cloud-backend.ts

@@ -21,7 +21,7 @@
 import { createLogger } from '@sim/logger'
 import { generateShortId } from '@sim/utils/id'
 import { truncate } from '@sim/utils/string'
-import { getMaxExecutionTimeout } from '@/lib/core/execution-limits'
+import { getMaxExecutionTimeout, getRemainingExecutionMs } from '@/lib/core/execution-limits'
 import { withPiSandbox } from '@/lib/execution/remote-sandbox'
 import { resolvePiSandboxLifetimeMs } from '@/lib/execution/remote-sandbox/pi-lifetime'
 import { runBabysitPi } from '@/executor/handlers/pi/babysit-backend'
@@ -439,7 +439,15 @@ export const runCloudPi: PiBackendRun<PiCloudRunParams> = async (params, context
     return combineCreateAndBabysit(created, skippedBabysitResult('startup_failure'))
   }
 
-  const remainingExecutionMs = Math.max(0, getMaxExecutionTimeout() - (Date.now() - startedAt))
+  // The run's own deadline when the platform set one, because Babysit spends this
+  // budget sitting in waits: planning against `getMaxExecutionTimeout()` — the
+  // longest-lived plan's async ceiling — meant a sync run was killed mid-loop with
+  // the PR already opened, its review comments already posted, and none of the
+  // `rounds`/`stopReason` outputs produced. The ceiling stays as the fallback for an
+  // untimed execution, where it is the only bound available.
+  const remainingExecutionMs =
+    getRemainingExecutionMs(context.signal) ??
+    Math.max(0, getMaxExecutionTimeout() - (Date.now() - startedAt))
   const sandboxBudgetMs = resolvePiSandboxLifetimeMs() ?? getMaxExecutionTimeout()
   const babysit = await runBabysitPi(
     {

apps/sim/lib/core/execution-limits/types.test.ts

@@ -35,6 +35,7 @@ declare module '@/lib/core/execution-limits/types?execution-limits-test' {
 import {
   createTimeoutAbortController,
   getExecutionTimeout,
+  getRemainingExecutionMs,
   isTimeoutAbortReason,
 } from '@/lib/core/execution-limits/types?execution-limits-test'
 
@@ -113,3 +114,42 @@ describe('getExecutionTimeout', () => {
     controller.cleanup()
   })
 })
+
+describe('getRemainingExecutionMs', () => {
+  it('reports the time left on the signal that enforces the timeout', () => {
+    const controller = createTimeoutAbortController(60_000)
+
+    const remaining = getRemainingExecutionMs(controller.signal)
+
+    expect(remaining).toBeGreaterThan(55_000)
+    expect(remaining).toBeLessThanOrEqual(60_000)
+    controller.cleanup()
+  })
+
+  it('never reports a negative remainder once the deadline has passed', () => {
+    vi.useFakeTimers()
+    try {
+      const controller = createTimeoutAbortController(1_000)
+      vi.advanceTimersByTime(5_000)
+
+      expect(getRemainingExecutionMs(controller.signal)).toBe(0)
+      controller.cleanup()
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+
+  /**
+   * `undefined` is "unknown", not "unlimited" — an untimed run, a signal from
+   * somewhere else, or a derived signal all land here, and a caller that needs a
+   * bound has to keep its own fallback rather than assume the run is untimed.
+   */
+  it('returns undefined for an untimed, foreign, or absent signal', () => {
+    const untimed = createTimeoutAbortController()
+
+    expect(getRemainingExecutionMs(untimed.signal)).toBeUndefined()
+    expect(getRemainingExecutionMs(new AbortController().signal)).toBeUndefined()
+    expect(getRemainingExecutionMs(undefined)).toBeUndefined()
+    untimed.cleanup()
+  })
+})

apps/sim/lib/core/execution-limits/types.ts

@@ -157,12 +157,45 @@ export function isTimeoutAbortReason(reason: unknown): boolean {
   )
 }
 
+/**
+ * Absolute deadline of each timeout signal, keyed by the signal that enforces it.
+ *
+ * Recorded here rather than threaded through {@link ExecutionContext} so the
+ * number can never disagree with the timer that acts on it: both are established
+ * in the one place the timeout exists. Every entry point already hands the
+ * executor `timeoutController.signal`, so a block that holds the signal can ask
+ * how long it really has without any call site remembering to pass a second
+ * field. Weakly keyed, so an finished execution's entry is collectable.
+ */
+const signalDeadlines = new WeakMap<AbortSignal, number>()
+
+/**
+ * Wall-clock milliseconds left before `signal`'s own timeout fires.
+ *
+ * `undefined` means the deadline is unknown — an untimed execution, or a derived
+ * signal rather than the one {@link createTimeoutAbortController} produced. Treat
+ * that as "no information", not as "no limit": callers that need a bound should
+ * keep their own conservative fallback rather than assume the run is untimed.
+ *
+ * Use this instead of {@link getMaxExecutionTimeout} when the question is "how
+ * much time does *this* run have left" — that function answers the different
+ * question of how long the longest-lived plan may ever run, and is a large
+ * overestimate for a sync run or a lower-tier plan.
+ */
+export function getRemainingExecutionMs(signal?: AbortSignal): number | undefined {
+  if (!signal) return undefined
+  const deadline = signalDeadlines.get(signal)
+  if (deadline === undefined) return undefined
+  return Math.max(0, deadline - Date.now())
+}
+
 export function createTimeoutAbortController(timeoutMs?: number): TimeoutAbortController {
   const abortController = new AbortController()
   let isTimedOut = false
   let timeoutId: NodeJS.Timeout | undefined
 
   if (timeoutMs) {
+    signalDeadlines.set(abortController.signal, Date.now() + timeoutMs)
     timeoutId = setTimeout(() => {
       isTimedOut = true
       // AbortError with a typed message — see isTimeoutAbortReason.

apps/sim/tools/github/job_logs.test.ts

@@ -16,6 +16,17 @@ function logResponse(body: string): Response {
   return new Response(body, { headers: { 'Content-Type': 'text/plain' } })
 }
 
+/** A storage host that honoured the suffix range: 206 plus the full size. */
+function partialLogResponse(body: string, totalBytes: number): Response {
+  return new Response(body, {
+    status: 206,
+    headers: {
+      'Content-Type': 'text/plain',
+      'Content-Range': `bytes ${totalBytes - Buffer.byteLength(body)}-${totalBytes - 1}/${totalBytes}`,
+    },
+  })
+}
+
 describe('github_job_logs', () => {
   it('reads the per-job log endpoint, not the run-level archive', () => {
     const url = (jobLogsTool.request.url as (params: JobLogsParams) => string)(BASE_PARAMS)
@@ -50,7 +61,7 @@ describe('github_job_logs', () => {
 
     expect(result).toEqual({
       success: true,
-      output: { logs: 'boom\n', totalCharacters: 5, truncated: false },
+      output: { logs: 'boom\n', truncated: false, totalBytes: 5 },
     })
   })
 
@@ -64,7 +75,43 @@ describe('github_job_logs', () => {
 
     expect(result.output.logs).toHaveLength(40)
     expect(result.output.logs.endsWith('FAILED: expected 1 to be 2')).toBe(true)
-    expect(result.output).toMatchObject({ totalCharacters: log.length, truncated: true })
+    expect(result.output).toMatchObject({ totalBytes: log.length, truncated: true })
+  })
+
+  // A verbose CI job exceeds the executor's 10 MB response cap, which throws rather
+  // than truncating — so asking for only the tail is what keeps a diagnostic available
+  // on exactly the runs that most need one.
+  it('asks the storage host for only the tail it intends to keep', () => {
+    const headers = jobLogsTool.request.headers({ ...BASE_PARAMS, maxCharacters: 4_096 })
+
+    expect(headers.Range).toBe('bytes=-4096')
+  })
+
+  it('trims the partial first line of a ranged response and reports the full size', async () => {
+    const result = await jobLogsTool.transformResponse!(
+      partialLogResponse('ise\nFAILED: expected 1 to be 2', 10_000),
+      { ...BASE_PARAMS, maxCharacters: 4_096 }
+    )
+
+    expect(result.output).toEqual({
+      logs: 'FAILED: expected 1 to be 2',
+      truncated: true,
+      totalBytes: 10_000,
+    })
+  })
+
+  // A host that ignores the range answers 200 with the whole body, so the local
+  // slice has to remain the fallback rather than an assumption about partiality.
+  it('falls back to the local slice when the range is ignored', async () => {
+    const log = `${'noise\n'.repeat(100)}tail`
+
+    const result = await jobLogsTool.transformResponse!(logResponse(log), {
+      ...BASE_PARAMS,
+      maxCharacters: 10,
+    })
+
+    expect(result.output.logs).toBe(log.slice(-10))
+    expect(result.output).toMatchObject({ truncated: true, totalBytes: log.length })
   })
 
   it('rejects a cap outside the supported range', async () => {

apps/sim/tools/github/job_logs.ts

@@ -28,23 +28,44 @@ function jobLogsPath(owner: string, repo: string, jobId: number): string {
   return `${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/actions/jobs/${jobId}/logs`
 }
 
+/**
+ * Total size from a `Content-Range: bytes <start>-<end>/<total>` header.
+ *
+ * `null` for an unsatisfied-range form, an unknown total, an unparsable value, or
+ * an absent header — all of which mean the full size is simply unknown here.
+ */
+function parseContentRangeTotal(header: string | null): number | null {
+  const total = header?.match(/^bytes\s+\d+-\d+\/(\d+)$/)?.[1]
+  if (!total) return null
+  const parsed = Number(total)
+  return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : null
+}
+
 /**
  * The tail is what matters: a failing job reports its error at the end.
  *
- * Reading the whole body first is safe because the tool executor already caps a
- * response at 10 MB and hands `transformResponse` a buffer, so a log larger than
- * that fails with the executor's size-limit error before reaching here — which
- * is the honest outcome, since a truncated head would read as a passing job.
+ * A ranged response already *is* the tail, so it is only trimmed at the first
+ * line break — the byte window almost always cuts mid-line, and it can also split
+ * a multi-byte character into a replacement char. A full response is sliced
+ * locally instead, which is the path taken whenever the storage host ignores the
+ * range and answers 200.
  */
 function logTail(
   text: string,
-  maxCharacters: number
-): { logs: string; totalCharacters: number; truncated: boolean } {
-  return {
-    logs: text.slice(-maxCharacters),
-    totalCharacters: text.length,
-    truncated: text.length > maxCharacters,
+  maxCharacters: number,
+  partial: boolean,
+  totalBytes: number | null
+): { logs: string; truncated: boolean; totalBytes: number | null } {
+  if (!partial) {
+    return {
+      logs: text.slice(-maxCharacters),
+      truncated: text.length > maxCharacters,
+      totalBytes: totalBytes ?? Buffer.byteLength(text),
+    }
   }
+  const firstBreak = text.indexOf('\n')
+  const trimmed = firstBreak === -1 ? text : text.slice(firstBreak + 1)
+  return { logs: trimmed.slice(-maxCharacters), truncated: true, totalBytes }
 }
 
 export const jobLogsTool: ToolConfig<JobLogsParams, JobLogsResponse> = {
@@ -98,6 +119,13 @@ export const jobLogsTool: ToolConfig<JobLogsParams, JobLogsResponse> = {
       Accept: 'application/vnd.github+json',
       Authorization: `Bearer ${params.apiKey}`,
       'X-GitHub-Api-Version': '2022-11-28',
+      // Ask the storage host for only the tail we intend to keep. A CI job with a
+      // verbose build routinely exceeds the executor's 10 MB response cap, and that
+      // cap throws rather than truncating — so without this a large log yielded no
+      // diagnostic at all, on exactly the runs that most need one. A suffix range is
+      // a request, not a guarantee: a host that ignores it answers 200 with the full
+      // body and the local slice below still applies.
+      Range: `bytes=-${resolveMaxCharacters(params.maxCharacters)}`,
     }),
     // The redirect target is third-party blob storage. Sim's tool fetch follows
     // redirects itself rather than through the fetch spec, so without this the
@@ -107,15 +135,24 @@ export const jobLogsTool: ToolConfig<JobLogsParams, JobLogsResponse> = {
 
   transformResponse: async (response, params) => {
     const maxCharacters = resolveMaxCharacters(params?.maxCharacters)
-    return { success: true, output: logTail(await response.text(), maxCharacters) }
+    const partial = response.status === 206
+    const totalBytes = parseContentRangeTotal(response.headers.get('content-range'))
+    return {
+      success: true,
+      output: logTail(await response.text(), maxCharacters, partial, totalBytes),
+    }
   },
 
   outputs: {
     logs: { type: 'string', description: 'Trailing portion of the job log' },
-    totalCharacters: { type: 'number', description: 'Full length of the log before truncation' },
     truncated: {
       type: 'boolean',
       description: 'Whether earlier output was dropped to fit maxCharacters',
     },
+    totalBytes: {
+      type: 'number',
+      description: 'Full size of the log in bytes, null when the server did not report it',
+      nullable: true,
+    },
   },
 }

apps/sim/tools/github/pr.ts

@@ -18,30 +18,8 @@ import type {
   PullRequestResponse,
   PullRequestV2Response,
 } from '@/tools/github/types'
-import {
-  BRANCH_REF_OUTPUT_PROPERTIES,
-  PR_FILE_OUTPUT_PROPERTIES,
-  USER_OUTPUT,
-} from '@/tools/github/types'
-import type { OutputProperty, ToolConfig } from '@/tools/types'
-
-/**
- * The PR reader's own branch-reference output. `repo_full_name` is declared here
- * rather than on the shared `BRANCH_REF_OUTPUT_PROPERTIES` because `list_prs`
- * reuses those with a pass-through transform that never derives the field.
- */
-const PR_BRANCH_REF_OUTPUT = {
-  type: 'object',
-  description: 'Branch reference info',
-  properties: {
-    ...BRANCH_REF_OUTPUT_PROPERTIES,
-    repo_full_name: {
-      type: 'string',
-      description: "Full name (owner/repo) of the branch's repository",
-      nullable: true,
-    },
-  },
-} as const satisfies OutputProperty
+import { PR_BRANCH_REF_OUTPUT, PR_FILE_OUTPUT_PROPERTIES, USER_OUTPUT } from '@/tools/github/types'
+import type { ToolConfig } from '@/tools/types'
 
 type GitHubPullRequest = Omit<GitHubPullRequestV2Output, 'files'>