test(pi): clarify exact native file byte semantics

Keep the memory JSON, byte graders, model, permissions, and production profile unchanged. Record the admitted shipping source and retained model-behavior failure separately from the changed qualification prompt.

Co-Authored-By: Paperclip <noreply@paperclip.ing>

doc/plans/2026-10-02-pi-production-readiness.md

@@ -94,6 +94,46 @@ $4.508407789 remaining. Billing snapshots are provisional. Reclaim only inspecte
 quiescent resources from the owned qualification host after retaining their evidence;
 require disk headroom and zero leaked native snapshots before subsequent paid cases.
 
+## Exact shutdown source qualification — 2026-10-07
+
+Production and installed packages are frozen at
+`06a3d9739f402baa7f8be7aaa29dda6db7354bfb`; protocol definitions are frozen at
+`d38ebc674d9138b941908d5128321e91db05a3a8`. Normal workspace/public builds,
+consumer installation and lifecycle hooks, strict graphs, Pi setup and real
+server/UI admission pass. All 20 archives are hash-verified and retained.
+[Hosted image build](https://github.com/paperclipai/paperclip/actions/runs/37676853634)
+passes. Image `sha256:5e62c8e294cd9d663316ba09b0aae1d7358a8938fe37d17936ef394cf1723ab2`
+passes anonymous Linux admission and an actual credential-free Daytona probe;
+probe deletion is confirmed. Current-source CI passes 54 checks with two skips.
+Nine simultaneous runner shutdowns are retained as infrastructure interruptions;
+a single failed-job rerun passes. Both PRs have zero unresolved review threads.
+
+Stop, same-turn steering and native questions pass on these installed bytes.
+Independent cleanup after each finds zero native snapshots, temporary roots,
+owned runtime processes or credential input files. The fresh memory case then
+fails its unchanged exact-byte grader: the native read and public managed-file
+API both return the expected 32-character value without its required line feed.
+The original 38 MB of canonical evidence and failure classification are retained;
+the sequence halts with no subsequent paid dispatch or automatic retry.
+
+A free probe against the actual installed Pi write/read modules proves that
+32-byte and 33-byte inputs are written and read unchanged, with no newline
+insertion or trimming. The task JSON independently decodes to the correct
+33-byte value. The supported cause is model behavior, separate from the original
+canonical candidate-failure classification. The only fixture correction explains
+that write never appends a newline and complete read preserves it. Original
+JSON, exact-byte graders, cross-root denial, model, low thinking, deadlines,
+permissions and production profile 18 remain unchanged. Qualification must use
+a recorded new harness revision for this changed prompt; shipping artifacts
+remain frozen at `06a3d9739`.
+
+The owned 10 GB build host is resumed after its unsupported disk-resize endpoint
+rejected a request. Four exact checksum-verified toolchain download caches are
+reclaimed after rechecking all 20 package archives and daemon bytes. Installed
+tools and all canonical evidence remain retained. The 2 GB disk admission floor,
+finite host lifetime and independent zero-snapshot cleanup stay in force.
+No local Docker is used and no rollout, release or merge is authorized.
+
 ## Final fixture reconciliation — 2026-10-07
 
 Fresh Linux CI passed the server, database, UI and package checks. It exposed

tests/runner-e2e/FIXTURES.md

@@ -432,6 +432,10 @@ editor's Markdown paste path; filling the editor directly produces escaped
 paragraph text instead of a code block. The issue API preserves literal escapes
 in real multiline bodies and only recovers self-escaped line breaks in legacy
 single-line bodies. Code fences and JSON escapes must survive both boundaries.
+The prompt explicitly states that native write never adds a newline and that
+complete native read preserves one when present. A credential-free probe of the
+installed Pi 1.0.0 tools checks both a 32-byte value and the 33-byte value with a
+final line feed; both write and read retain the exact supplied bytes.
 The prompt orders one memory write, one complete native read, a separate expected
 cross-root write denial, and then completion. Native paths use the exact current
 absolute agent directory; shell-variable expansion is not assumed. An incorrect

tests/runner-e2e/pi-native-cases.ts

@@ -29,6 +29,7 @@ export function piNativeMemoryPrompt(nonce: string, outsidePath?: string): strin
     "Follow these steps in order. Use native file tools; do not use bash or the instructions API.",
     "1. Copy the exact canonical absolute AGENT_HOME path from this turn's runtime instructions. Native file paths do not expand $AGENT_HOME. Do not use a remembered path or reconstruct any directory name.",
     `2. Call native write exactly once with the JSON arguments below. Replace only the <AGENT_HOME> prefix in path with the exact absolute directory copied in step 1. Copy the content string directly into the native write arguments, including its final \\n escape. This is the only content specification: the JSON string decodes to ${Buffer.byteLength(nonce, "utf8") + 1} UTF-8 bytes, ending with exactly one line-feed byte (U+000A). Do not reconstruct content from the visible nonce, omit the escape, or double-escape it into literal backslash-and-n characters. This is personal memory, not a task deliverable. Do not edit AGENTS.md or a project file.`,
+    "Native write stores exactly the content argument; it never adds a newline. Include the final JSON newline escape in the write argument itself. Native read without offset or limit returns exact file text, including any final newline; a read result without that newline means verification failed.",
     "```json",
     JSON.stringify({ path: `<AGENT_HOME>/${PI_NATIVE_MEMORY_PATH}`, content: `${nonce}\n` }),
     "```",