diff --git a/.agents/notes/implemented/bug-fix/2026-07-31-code-runtime-python-settlement-fixes.i18n.yaml b/.agents/notes/implemented/bug-fix/2026-07-31-code-runtime-python-settlement-fixes.i18n.yaml index 1cb412dfb6..4d6e577790 100644 --- a/.agents/notes/implemented/bug-fix/2026-07-31-code-runtime-python-settlement-fixes.i18n.yaml +++ b/.agents/notes/implemented/bug-fix/2026-07-31-code-runtime-python-settlement-fixes.i18n.yaml @@ -2,5 +2,5 @@ # side as of the last confirmed-consistent state. Both languages carry equal authority; # after editing either side, bring the other along and re-record with: # pnpm run verify-translation-pairing --write .agents/notes/implemented/bug-fix/2026-07-31-code-runtime-python-settlement-fixes.md -2026-07-31-code-runtime-python-settlement-fixes.md: f485f28e12dbffd386fd57755d657252dfed5daf -2026-07-31-code-runtime-python-settlement-fixes.zh.md: 5a6b8673ce313516ada5900a910dd15d126c1af3 +2026-07-31-code-runtime-python-settlement-fixes.md: 6a3b484a27906df2e9fd92785bb9b767d889b165 +2026-07-31-code-runtime-python-settlement-fixes.zh.md: 1c6223195308d764d3fa51f63d34e36873d49548 diff --git a/.agents/notes/implemented/bug-fix/2026-07-31-code-runtime-python-settlement-fixes.md b/.agents/notes/implemented/bug-fix/2026-07-31-code-runtime-python-settlement-fixes.md index f485f28e12..6a3b484a27 100644 --- a/.agents/notes/implemented/bug-fix/2026-07-31-code-runtime-python-settlement-fixes.md +++ b/.agents/notes/implemented/bug-fix/2026-07-31-code-runtime-python-settlement-fixes.md @@ -92,7 +92,7 @@ Also in `src/index.ts`, the binding-rejection catch branch now checks `settled` ### A newline-free drip seals its fragments; the CPU soft limit is kept below the hard; the done frame falls back to a fixed literal; the reply queue clears consumed slots -In [`py/bootstrap.py`](../../../../packages/code-runtime/code-runtime-python/py/bootstrap.py), `_LogStream` now seals the pending-fragment list past a cap: a newline-free drip of one character per `write` would otherwise accumulate one list slot (and one str object) per call, and under a large `maxLogBytes` a 25 M single-character flood OOMs on its own accounting (plus the same-size list `_push_bounded_prefix` then builds) before the byte budget is reached. Past `_PENDING_MAX_CHUNKS` the current fragments are joined into ONE block moved to a `_pending_blocks` list (the character count is unchanged), bounding the live fragment count exactly as the host-side `captureStray` seal does; the join is only the ≤cap current fragments, never the whole accumulated buffer, so a large drip stays O(B) rather than re-copying the growing block O(B²/cap) times. +In [`py/bootstrap.py`](../../../../packages/code-runtime/code-runtime-python/py/bootstrap.py), `_LogStream` now seals the pending-fragment list past a cap: a newline-free drip of one character per `write` would otherwise accumulate one list slot (and one str object) per call, and under a large `maxLogBytes` a 25 M single-character flood OOMs on its own accounting (plus the same-size list `_push_bounded_prefix` then builds) before the byte budget is reached. Past `_PENDING_MAX_CHUNKS` the current fragments are joined into ONE block moved to a `_pending_blocks` list (the character count is unchanged), bounding the live fragment count exactly as the host-side `captureStray` seal does; the join is only the ≤cap current fragments, never the whole accumulated buffer, so a large drip stays O(B) rather than re-copying the growing block O(B²/cap) times. The HOST-side open hold mirrors the same seal: a budget-sized single-character open flood (`print('x', end='', flush=True)` in a loop is an honest-child path) would otherwise accumulate one fragment array slot plus string object header per frame — ~30× overhead the byte cap cannot see, up to ~2 GB of host auxiliary heap near the `maxLogBytes` load ceiling. Past `MAX_PENDING_CHUNKS` the held fragments coalesce into `openSealed`; the closing-frame merge, `truncateLogs`, and the `finish` residual all read sealed + current fragments and clear the seal. `_clamped` also lowers a clamped RLIMIT_CPU soft limit that EQUALS the hard by one unit (when the hard is at least 2). A `ulimit -t N` sets both, and with soft == hard the kernel checks the hard limit in the same tick and SIGKILLs a busy loop directly, so SIGXCPU is never delivered — and the host classifies a CPU overrun ONLY on `signal === 'SIGXCPU'`, so a definite budget exhaustion would be misreported as a `worker-exit`. Lowering the soft one unit gives SIGXCPU a window to fire, so the overrun is reported as a timeout. This is scoped to RLIMIT_CPU (a one-byte soft differential on RLIMIT_AS would only misalign the child's applied limit with the host budget gate, with no signal to preserve). The `hard >= 2` guard leaves a `hard == 1` blind spot — a 1-second dual limit cannot lower the soft to 0, so a definite overrun there is still reported as `worker-exit`. diff --git a/.agents/notes/implemented/bug-fix/2026-07-31-code-runtime-python-settlement-fixes.zh.md b/.agents/notes/implemented/bug-fix/2026-07-31-code-runtime-python-settlement-fixes.zh.md index 5a6b8673ce..1c62231953 100644 --- a/.agents/notes/implemented/bug-fix/2026-07-31-code-runtime-python-settlement-fixes.zh.md +++ b/.agents/notes/implemented/bug-fix/2026-07-31-code-runtime-python-settlement-fixes.zh.md @@ -92,7 +92,7 @@ Status: implemented ### 无换行滴灌会封存其分片;CPU 软限制保持在硬限制之下;done 帧回退到固定字面量;回复队列清空已消费槽位 -在 [`py/bootstrap.py`](../../../../packages/code-runtime/code-runtime-python/py/bootstrap.py) 中,`_LogStream` 现在会在待处理分片列表越过一个上限时封存它:无换行、每次 `write` 一个字符的滴灌会每次调用累积一个 list 槽位(以及一个 str 对象),在一个大的 `maxLogBytes` 下,25 M 次单字符洪泛会在字节预算达到之前,于其自身记账上 OOM(加上 `_push_bounded_prefix` 随后构造的同规模列表)。越过 `_PENDING_MAX_CHUNKS` 后,当前分片被 join 成一个块并移入 `_pending_blocks` 列表(字符数不变),把存活的碎片数量限制在宿主侧 `captureStray` 封存所做的同等水平;该 join 只针对 ≤cap 的当前分片,从不针对整个累积缓冲,因此大的滴灌保持 O(B),而不是以 O(B²/cap) 次反复复制不断增长的块。 +在 [`py/bootstrap.py`](../../../../packages/code-runtime/code-runtime-python/py/bootstrap.py) 中,`_LogStream` 现在会在待处理分片列表越过一个上限时封存它:无换行、每次 `write` 一个字符的滴灌会每次调用累积一个 list 槽位(以及一个 str 对象),在一个大的 `maxLogBytes` 下,25 M 次单字符洪泛会在字节预算达到之前,于其自身记账上 OOM(加上 `_push_bounded_prefix` 随后构造的同规模列表)。越过 `_PENDING_MAX_CHUNKS` 后,当前分片被 join 成一个块并移入 `_pending_blocks` 列表(字符数不变),把存活的碎片数量限制在宿主侧 `captureStray` 封存所做的同等水平;该 join 只针对 ≤cap 的当前分片,从不针对整个累积缓冲,因此大的滴灌保持 O(B),而不是以 O(B²/cap) 次反复复制不断增长的块。宿主侧 open hold 镜像同样的封存:预算内的单字符 open 洪泛(`print('x', end='', flush=True)` 循环是诚实子进程可达路径)否则会为每帧累积一个片段数组槽位加字符串对象头——约 30× 字节计数看不到的开销,在 `maxLogBytes` 装载上限附近最高约 2 GB 宿主辅助堆。越过 `MAX_PENDING_CHUNKS` 后持有的片段并入 `openSealed`;闭合帧合并、`truncateLogs` 与 `finish` 残段都读取 sealed 加当前片段并清空封存。 `_clamped` 还会把钳制出的、与硬限制相等的 RLIMIT_CPU 软限制降低一个单位(当硬限制至少为 2 时)。`ulimit -t N` 会同时设置两者,而当 soft == hard 时,内核会在同一 tick 检查硬限制并直接 SIGKILL 一个忙循环,因此 SIGXCPU 永远不会送达——而宿主只在 `signal === 'SIGXCPU'` 时把 CPU 超限分类为超时,所以一次确定的预算耗尽会被误报为 `worker-exit`。把软限制降低一个单位给 SIGXCPU 一个触发窗口,因此超限会被报告为超时。这仅限定于 RLIMIT_CPU(在 RLIMIT_AS 上的一字节软差异只会让子进程实际应用的限制与宿主预算门失步,没有需要保留的信号)。`hard >= 2` 守卫留下了 `hard == 1` 盲区——一个 1 秒的双限制无法把软限制降到 0,因此那里的确定超限仍被报告为 `worker-exit`。 diff --git a/packages/code-runtime/code-runtime-python/src/index.ts b/packages/code-runtime/code-runtime-python/src/index.ts index d394569492..48891023fb 100644 --- a/packages/code-runtime/code-runtime-python/src/index.ts +++ b/packages/code-runtime/code-runtime-python/src/index.ts @@ -1567,6 +1567,13 @@ export class PythonCodeRuntime extends CodeRuntime { // billed cost cost - 2 fits exactly when the walk's cost is at // most logBudget + 2). if (!logsTruncated) { + // An EMPTY first open frame (openParts empty AND text '') bills + // cost + 1 = 3 but establishes no hold (the push is skipped), + // so the next frame is billed as a new first fragment. Not + // reachable from an honest child (_LogStream.write('') returns + // early; flush_line pushes only non-empty pending); for a + // forged frame it is a bounded over-charge in the safe + // direction (a flood exhausts the ledger into truncation). const cap = openParts.length === 0 ? logBudget - 1 : logBudget + 2 const cost = jsonStringCostUpTo(message.text, cap) if (cost === undefined) { diff --git a/packages/code-runtime/code-runtime-python/tests/runtime.spec.ts b/packages/code-runtime/code-runtime-python/tests/runtime.spec.ts index 7069ddf585..3c2a5fe2e0 100644 --- a/packages/code-runtime/code-runtime-python/tests/runtime.spec.ts +++ b/packages/code-runtime/code-runtime-python/tests/runtime.spec.ts @@ -1968,6 +1968,31 @@ describe('PythonCodeRuntime — programs and bindings', () => { expect(result.logs).toEqual(['a'.repeat(60), logTruncationMarker(64)]) }, 15_000) + it('commits a sealed open hold before the truncation marker', async () => { + // The sealed variant of the prefix-commit case: an open flood past + // MAX_PENDING_CHUNKS lands in openSealed, then an over-budget line + // truncates — truncateLogs must commit the SEALED prefix (not only the + // current fragments) before the marker. + const { runtime } = await setup({ maxLogBytes: 65536 }) + const result = await runtime.run({ + program: [ + 'import os', + "os.write(3, b'{\"type\":\"log\",\"text\":\"x\",\"open\":true}\\n')", + // 3000 single-character open continuations seal the hold, then a + // forged over-budget open frame trips the ledger: truncateLogs must + // commit the SEALED prefix before the marker. + 'for _ in range(3000):', + " os.write(3, b'{\"type\":\"log\",\"text\":\"a\",\"open\":true}\\n')", + "os.write(3, ('{\"type\":\"log\",\"text\":\"' + 'z' * 70000 + '\",\"open\":true}\\n').encode())", + 'return "done"', + ].join('\n'), + bindings: [], + }) + expect(result.error).toBeUndefined() + expect(result.logs[0]).toBe('x' + 'a'.repeat(3000)) + expect(result.logs[result.logs.length - 1]).toBe(logTruncationMarker(65536)) + }, 15_000) + it('commits a flushed open prefix before the truncation marker', async () => { // A flushed unterminated line is billed and committed; when a later // over-budget write truncates, the committed prefix must appear BEFORE the