@@ -33,6 +33,9 @@ ultimate source of truth. Upstream test262 files run verbatim from `test/test262
 - [x] The global `search(...)` built-in: synchronous tool discovery that counts as an admitted tool call and is
       shadowable by program declarations like other globals.
 - [x] Cooperative timeout, an optional total tool-call limit, output bounding, and unrestricted tool-call concurrency.
+- [x] Optional stall detection (`stallMs`): a program body that takes no step for the whole window while no tool or
+      extension call is running fails with `Stalled`. Without timers, only those calls or the program's own steps can
+      settle a promise, so such a program is awaiting one that never settles, as in `await new Promise(() => {})`.
 - [x] The timeout fires between interpreter steps, so one built-in is bounded in what it may build: strings up to
       2^24 characters (`repeat`, `pad*`, `concat`, `join`, `+`, template literals, `JSON.stringify`), arrays up to
       10,000,000 elements (`Array(n)`, `length =`, `Array.from`, `split`, `matchAll`, `concat`, `flat`; below the JS
 
@@ -25,6 +25,11 @@ export type ExecutionLimits = {
    * No default: absent means no timeout.
    */
   readonly timeoutMs?: number
+  /**
+   * Milliseconds the program may wait with no step taken and no tool or extension call running before it fails as
+   * stalled. Such a program is awaiting a promise nothing can settle. No default: absent means no stall detection.
+   */
+  readonly stallMs?: number
   /** Maximum number of tool calls admitted by the runtime. No default: absent means unlimited. */
   readonly maxToolCalls?: number
   /**
@@ -36,6 +41,7 @@ export type ExecutionLimits = {
 
 export type ResolvedExecutionLimits = {
   readonly timeoutMs: number | undefined
+  readonly stallMs: number | undefined
   readonly maxToolCalls: number | undefined
   readonly maxOutputBytes: number | undefined
 }
@@ -74,6 +80,7 @@ export const DiagnosticKind = Schema.Literals([
   "InvalidDataValue",
   "ToolCallLimitExceeded",
   "TimeoutExceeded",
+  "Stalled",
   "ToolFailure",
   "ExecutionFailure",
   "Truncated",
@@ -132,6 +139,7 @@ const validateLimit = (name: keyof ExecutionLimits, value: number | undefined, m
 
 const resolveExecutionLimits = (limits?: ExecutionLimits): ResolvedExecutionLimits => ({
   timeoutMs: validateLimit("timeoutMs", limits?.timeoutMs, 1),
+  stallMs: validateLimit("stallMs", limits?.stallMs, 1),
   maxToolCalls: validateLimit("maxToolCalls", limits?.maxToolCalls, 0),
   maxOutputBytes: validateLimit("maxOutputBytes", limits?.maxOutputBytes, 0),
 })
 
@@ -0,0 +1,40 @@
+import { Effect } from "effect"
+
+/**
+ * Promises settle only through program steps or host calls, so a program that takes no step while no host call is
+ * running is waiting on something that can never settle, such as `await new Promise(() => {})`.
+ */
+export class Activity {
+  /** Counts program steps and host calls starting or ending; the hot path only increments it. */
+  steps = 0
+  private running = 0
+
+  track<A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> {
+    return Effect.acquireUseRelease(
+      Effect.sync(() => {
+        this.steps++
+        this.running++
+      }),
+      () => effect,
+      // Ending counts too: a call can settle just before a check, ahead of the step that consumes its result.
+      () =>
+        Effect.sync(() => {
+          this.steps++
+          this.running--
+        }),
+    )
+  }
+
+  /** Completes once a full `idleMs` window passes with no step and no host call running. */
+  stalled(idleMs: number): Effect.Effect<void> {
+    const self = this
+    return Effect.gen(function* () {
+      let steps = self.steps
+      while (true) {
+        yield* Effect.sleep(idleMs)
+        if (self.running === 0 && self.steps === steps) return
+        steps = self.steps
+      }
+    })
+  }
+}
@@ -8,6 +8,7 @@ import type { Value } from "./objects.js"
 import { createBuiltins } from "./intrinsics.js"
 import { Pending } from "./promises.js"
 import { Interpreter } from "./interpreter.js"
+import { Activity } from "./activity.js"
 
 export const executeProgram = <R>(
   code: string,
@@ -29,6 +30,7 @@ export const executeProgram = <R>(
     const builtins = createBuiltins()
     const tools = ToolRuntime.make(prepared, limits.maxToolCalls, hooks)
     const logs: Array<string> = []
+    const activity = new Activity()
     const logged = () => (logs.length > 0 ? { logs: [...logs] } : {})
     // Set only after copy-out so timeouts cannot report invalid values as completed.
     let returned: { value: DataValue; pending: Pending<R> } | undefined
@@ -39,7 +41,7 @@ export const executeProgram = <R>(
         Effect.gen(function* () {
           const program = parseProgram(code)
           const pending = new Pending<R>(scope, builtins.Promise)
-          const ctx = new Interpreter<R>({ tools, pending, builtins, logs, globals })
+          const ctx = new Interpreter<R>({ tools, pending, builtins, logs, activity, globals })
           const result = (yield* toBoundary(ctx, yield* ctx.run(program))) ?? null
           returned = { value: result, pending }
           const warnings = yield* pending.interrupt()
@@ -53,11 +55,35 @@ export const executeProgram = <R>(
         }),
       (scope, exit) => Scope.close(scope, exit),
     )
+    const stallMs = limits.stallMs
+    // Only the program body can stall; once it returns, settling background work is bounded by the timeout.
+    // Cleanup runs through tracked calls, so the guard below is a backstop for cleanup that is slow while untracked.
+    const watched =
+      stallMs === undefined
+        ? base
+        : Effect.raceFirst(
+            base,
+            activity.stalled(stallMs).pipe(
+              Effect.flatMap(() => (returned === undefined ? Effect.void : Effect.never)),
+              Effect.map(
+                () =>
+                  ({
+                    ok: false,
+                    error: {
+                      kind: "Stalled",
+                      message: `Execution stalled: nothing ran for ${stallMs}ms while the program awaited a promise that no running call can settle. Timers are unavailable, so a promise settles only through a tool or extension call, or by calling its resolve or reject.`,
+                    },
+                    ...logged(),
+                    toolCalls: tools.calls,
+                  }) satisfies Result,
+              ),
+            ),
+          )
     const timeoutMs = limits.timeoutMs
     const operation =
       timeoutMs === undefined
-        ? base
-        : base.pipe(
+        ? watched
+        : watched.pipe(
             Effect.timeoutOrElse({
               duration: timeoutMs,
               orElse: () =>
 
@@ -140,14 +140,18 @@ export const extensionGlobals = <R>(
     fn<R>(builtins, value.name, value.length, (_, values) => {
       const args = values.map((item, index) => toHost(item, `Argument ${index + 1} to ${label}`))
       const hooks = ctx.tools.hooks
+      // Track the hooks too: a slow `extension.before` is a call in flight, as `tool.before` is.
       const settle = (run: Effect.Effect<unknown, unknown, R>) =>
-        (describe === undefined
-          ? run
-          : hooked(describe(args), hooks["extension.before"], hooks["extension.after"], run)
-        ).pipe(
-          Effect.mapError((reason) => new Throw(fromHost(reason, label))),
-          Effect.map((settled) => fromHost(settled, label)),
-        )
+        ctx.activity
+          .track(
+            describe === undefined
+              ? run
+              : hooked(describe(args), hooks["extension.before"], hooks["extension.after"], run),
+          )
+          .pipe(
+            Effect.mapError((reason) => new Throw(fromHost(reason, label))),
+            Effect.map((settled) => fromHost(settled, label)),
+          )
       let result: unknown
       try {
         result = value.apply(undefined, args)
 
@@ -99,6 +99,7 @@ import { type Hint, preserveConsumerError, toPrimitive } from "./callback.js"
 import { Pending, resolvePromise, resolvePromiseValue } from "./promises.js"
 import { describeValue, isOpaque, rejectCircularInsertion, typeofValue } from "./references.js"
 import { ScopeStack } from "./scope.js"
+import { Activity } from "./activity.js"
 import { constructRegExp } from "../stdlib/regexp.js"
 import { enumerableSource } from "../stdlib/object.js"
 import { compoundOperators } from "../stdlib/value.js"
@@ -316,6 +317,7 @@ export class Interpreter<R> {
   readonly pending: Pending<R>
   readonly builtins: Builtins
   readonly logs: Array<string>
+  readonly activity: Activity
   /** Template objects by site: a tag sees the same `strings` array every time its literal is evaluated, as in JS. */
   readonly templates = new WeakMap<TaggedTemplateExpression, Arr>()
   private readonly root: Frame<R>
@@ -325,12 +327,14 @@ export class Interpreter<R> {
     readonly pending: Pending<R>
     readonly builtins: Builtins
     readonly logs?: Array<string>
+    readonly activity?: Activity
     readonly globals?: (ctx: Interpreter<R>) => ReadonlyArray<readonly [string, Value]>
   }) {
     this.tools = options.tools
     this.pending = options.pending
     this.builtins = options.builtins
     this.logs = options.logs ?? []
+    this.activity = options.activity ?? new Activity()
     // Program code has no receiver: top-level `this` is undefined, as in a module.
     const globalScope = new Map<string, Binding>([["this", { mutable: false, value: undefined }]])
     // Calling back into the program never reads frame state, so any frame serves; the root is always alive.
@@ -368,7 +372,7 @@ export class Interpreter<R> {
     const ctx = this
     return Effect.gen(function* () {
       const json = yield* Effect.forEach(args, (arg) => toBoundary(ctx, arg))
-      return fromJson(ctx, yield* run(json))
+      return fromJson(ctx, yield* ctx.activity.track(run(json)))
     })
   }
 }
@@ -434,6 +438,7 @@ class Frame<R> {
   }
 
   private evaluateStatement(node: Statement | ModuleDeclaration): Effect.Effect<StatementResult, unknown, R> {
+    this.ctx.activity.steps++
     switch (node.type) {
       case "ExpressionStatement":
         return Effect.as(this.evaluateExpression(node.expression), { kind: "none" })
@@ -1289,6 +1294,7 @@ class Frame<R> {
   }
 
   private evaluateExpression(node: Expression): Effect.Effect<Value, unknown, R> {
+    this.ctx.activity.steps++
     switch (node.type) {
       case "Literal": {
         const regex = node.regex
 
@@ -1280,3 +1280,109 @@ describe("CodeMode public contract", () => {
     expect(elapsedMs).toBeLessThan(3_000)
   })
 })
+
+describe("CodeMode stall detection", () => {
+  const sleepy = (ms: number) =>
+    Tool.make({
+      description: "Resolve after a delay",
+      input: Schema.Struct({}),
+      output: Schema.String,
+      execute: () => Effect.as(Effect.sleep(ms), "done"),
+    })
+  const later = Extension.make({
+    name: "later",
+    globals: { later: () => new Promise((resolve) => setTimeout(() => resolve("late"), 150)) },
+  })
+  const stalls = (code: string, options: Omit<CodeMode.Options, "limits"> = {}) =>
+    Effect.runPromise(CodeMode.make({ ...options, limits: { stallMs: 50 } }).execute(code))
+
+  test("fails a program awaiting a promise nothing can settle", async () => {
+    for (const code of [
+      "await new Promise((resolve) => resolve); return 1",
+      "await new Promise(() => {}); return 1",
+      "const { promise } = Promise.withResolvers(); return await promise",
+    ]) {
+      const startedAt = Date.now()
+      const result = await stalls(code)
+      expect(result).toMatchObject({ ok: false, error: { kind: "Stalled" } })
+      expect(Date.now() - startedAt).toBeLessThan(2_000)
+    }
+  })
+
+  test("keeps the calls and logs made before the stall", async () => {
+    const result = await stalls('console.log("waiting"); await tools.host.wait({}); await new Promise(() => {})', {
+      tools: { host: { wait: sleepy(1) } },
+    })
+    expect(result).toMatchObject({
+      ok: false,
+      error: { kind: "Stalled" },
+      logs: ["waiting"],
+      toolCalls: [{ name: "host.wait" }],
+    })
+  })
+
+  test("waits for tool and extension calls that outlast the stall window", async () => {
+    expect(await stalls("return await tools.host.wait({})", { tools: { host: { wait: sleepy(150) } } })).toMatchObject({
+      ok: true,
+      value: "done",
+    })
+    expect(await stalls("return await later()", { extensions: [later] })).toMatchObject({ ok: true, value: "late" })
+  })
+
+  test("counts slow before hooks as calls in flight", async () => {
+    const slowBefore = { "tool.before": () => Effect.sleep(150), "extension.before": () => Effect.sleep(150) }
+    expect(
+      await stalls("return await tools.host.wait({})", { tools: { host: { wait: sleepy(1) } }, hooks: slowBefore }),
+    ).toMatchObject({ ok: true, value: "done" })
+    expect(await stalls("return await later()", { extensions: [later], hooks: slowBefore })).toMatchObject({
+      ok: true,
+      value: "late",
+    })
+  })
+
+  test("reports whichever of the stall and the timeout comes first", async () => {
+    const run = (code: string, limits: CodeMode.ExecutionLimits) =>
+      Effect.runPromise(CodeMode.make({ limits }).execute(code))
+    expect(await run("await new Promise(() => {})", { stallMs: 50, timeoutMs: 1_000 })).toMatchObject({
+      ok: false,
+      error: { kind: "Stalled" },
+    })
+    expect(await run("await new Promise(() => {})", { stallMs: 1_000, timeoutMs: 50 })).toMatchObject({
+      ok: false,
+      error: { kind: "TimeoutExceeded" },
+    })
+  })
+
+  test("reports slow cleanup after return as a timeout warning, not a stall", async () => {
+    // Interrupting the un-awaited call at return runs its `tool.after`, which outlasts both windows. The hook
+    // counts as a call in flight, so the stall watcher stays quiet and the timeout ends the cleanup.
+    const result = await Effect.runPromise(
+      CodeMode.make({
+        tools: { host: { wait: sleepy(10_000) } },
+        hooks: { "tool.after": () => Effect.sleep(400) },
+        limits: { stallMs: 50, timeoutMs: 200 },
+      }).execute("tools.host.wait({}); return 5"),
+    )
+    expect(result).toMatchObject({ ok: true, value: 5, warnings: [{ kind: "TimeoutExceeded" }] })
+  })
+
+  test("never stalls a program that keeps running", async () => {
+    const result = await stalls("let total = 0; for (let i = 0; i < 300000; i += 1) total += i; return total")
+    expect(result).toMatchObject({ ok: true, value: 44999850000 })
+  })
+
+  test("does not count an un-awaited promise left behind at return", async () => {
+    expect(await stalls("new Promise(() => {}); return 5")).toMatchObject({ ok: true, value: 5 })
+  })
+
+  test("is off unless the host sets stallMs", async () => {
+    const result = await Effect.runPromise(
+      CodeMode.make({ limits: { timeoutMs: 200 } }).execute("await new Promise(() => {})"),
+    )
+    expect(result).toMatchObject({ ok: false, error: { kind: "TimeoutExceeded" } })
+  })
+
+  test("rejects an invalid stallMs", () => {
+    expect(() => CodeMode.make({ limits: { stallMs: 0 } })).toThrow(RangeError)
+  })
+})
@@ -29,7 +29,7 @@ type Frontmatter = {
   negative?: { phase: "parse" | "resolution" | "runtime"; type: string }
 }
 
-const limits = { timeoutMs: 5000, maxToolCalls: undefined, maxOutputBytes: undefined }
+const limits = { timeoutMs: 5000, stallMs: undefined, maxToolCalls: undefined, maxOutputBytes: undefined }
 const prepared = ToolRuntime.prepare<never>({})
 
 export const run = async (file: string): Promise<Outcome> => {
 
@@ -58,6 +58,9 @@ export type Inventory = {
   readonly namespaces?: ReadonlyMap<string, ToolNamespace>
 }
 
+// A program that takes no step while no call is running can never resume; fail it instead of holding the turn.
+const STALL_MS = 30_000
+
 // Invariant model-facing guidance; the changing tool catalog is delivered through Instructions.
 const description = [
   "Run JavaScript in a confined Code Mode runtime to script tool calls and HTTP requests and compose their results.",
@@ -66,6 +69,7 @@ const description = [
   'Call tools through `tools` using only exact paths and signatures from the catalog. Do not infer or normalize tool names; preserve bracket notation such as `tools.<namespace>["tool-name"](input)`.',
   "Prefer an explicit `return`; if omitted, the final top-level expression becomes the result.",
   "Await every call whose completion matters; pending calls are interrupted when execution ends. Run independent calls concurrently with `Promise.allSettled`.",
+  "Do not use it to wait or poll: without timers it cannot sleep, and a program awaiting a promise that nothing can settle fails as stalled.",
 ].join("\n")
 
 export const create = (
@@ -236,7 +240,12 @@ function runtime(
     })
   }
   const tools = renderTools(root)
-  return CodeMode.make<typeof tools>({ tools, extensions: [CodeModeWeb.extension], hooks })
+  return CodeMode.make<typeof tools>({
+    tools,
+    extensions: [CodeModeWeb.extension],
+    hooks,
+    limits: { stallMs: STALL_MS },
+  })
 }
 
 function getNode<T>(root: Node<T>, path: string) {
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ type Frontmatter = {`
`29`	`29`	`negative?: { phase: "parse" \| "resolution" \| "runtime"; type: string }`
`30`	`30`	`}`
`31`	`31`
`32`		`-const limits = { timeoutMs: 5000, maxToolCalls: undefined, maxOutputBytes: undefined }`
	`32`	`+const limits = { timeoutMs: 5000, stallMs: undefined, maxToolCalls: undefined, maxOutputBytes: undefined }`
`33`	`33`	`const prepared = ToolRuntime.prepare<never>({})`
`34`	`34`
`35`	`35`	`export const run = async (file: string): Promise<Outcome> => {`