Repository navigation
record(loose): a '__proto__' field in loose text is silently dropped — parseLoose assigns into a plain object, so the field never reaches the JSONL line (the JSON path preserves it) #2828
Description
record(loose): a __proto__ field in loose text is silently dropped — parseLoose assigns into a plain object, so the field never reaches the JSONL line (the JSON path preserves it)
Repo: developing-today/code · Main: a047d531 · File: bin/record.mjs — parseLoose at lines 104–126 (field assignment at :115), normaliseInput at :132–145.
Evidence (verified this run, real module)
record's contract (file header, :12–19) is NEVER REJECT and "Agent-supplied fields are never rewritten, flattened, or validated — unknown keys pass through untouched." The loose-text path breaks that for exactly one key:
parseLoose collects segments into a plain object literal (const fields = {}, :105) and assigns fields[key] = value (:115). The key grammar (/^\s*([A-Za-z_][\w .-]*?)\s*[:=]/, :108) admits __proto__, and assigning to fields.__proto__ invokes the Object.prototype setter instead of creating an own property: a string value is ignored outright, and an object value silently replaces the fields object's prototype. Either way the key counts toward the two-keyed-segment threshold (:122) but never becomes a field.
Laptop probe (real module, md5 47b3304a4ee676b5b19b8129af5a3f49 matching main; probe retained at laptop ~/git/fleet/probe-2026-10-30-laneA-recordproto/):
- Control:
parseLoose('category=bad | finding: something broke')→{"category":"bad","finding":"something broke"}. parseLoose('__proto__=hello | category=bad')→{"category":"bad"}—__proto__gone,Object.keys=["category"].parseLoose('__proto__={"polluted":1} | category=bad')→{"category":"bad"}, and the fields object's prototype IS{polluted:1}(the value went to the prototype, not a field;Object.prototypeitself is not polluted —({}).pollutedstaysundefined).- End-to-end
record('__proto__=hello | category=bad', …)returnsrecordedand appends{"category":"bad","raw":"__proto__=hello | category=bad","ts":…,"pwd":…}— no__proto__field (it survives only inside the verbatimrawstring, and any later normalisation pass that re-runsparseLooseon that raw drops it again). - Asymmetry control: the JSON path preserves the same key —
record('{"__proto__":"hello","category":"bad"}', …)appends a line with an own"__proto__":"hello"field (Object.hasOwn(entry,'__proto__') === true), because JSON.parse + spread create it as a data property. constructor=xin loose text is preserved as an own field —__proto__is the only setter-special key the grammar admits.
Why it matters
record is the fleet's append-only observation log (#1853): its one hard rule is that a supplied field must not be lost, because a lost field costs the observation permanently. A loose recording that legitimately names a __proto__ field — exactly the kind of key an agent records when reporting a prototype-lookup bug (the fleet filed four of those this week: #2734/#2757/#2781/#2790) — is silently normalised into a line without that field, and the recording still reports success. The two input paths also disagree: the same observation sent as JSON keeps the field, sent as loose text loses it.
Related but distinct: #2792's design covers read-side own-key lookups and explicitly scopes write-side __proto__ handling out ("a different bug class", Phase 3 reports instances). This is that write-side instance, with field loss (not lookup fabrication and not global pollution) as the concrete harm — triage may route it under #2792's Phase 3 audit instead of a standalone fix; either disposition is fine, but it should be on record.
Acceptance criteria
- A loose-text
__proto__field reaches the appended JSONL line as an own field with its parsed value, exactly as the JSON path already does — for both string and object values. - Building the loose fields object never changes any object's prototype (the fields object keeps
Object.prototype, and no other object is affected). - Tests in
bin/record.test.mjspin: loose__proto__with a string value, loose__proto__with an object value, and the JSON-path control — all three lines carry the field. - All other loose/JSON behaviour is unchanged: the two-keyed-segment threshold,
rawride-along, stamp filling, quarantine path, and exit-0 / never-throw contract.
Dedup: searched open + closed issues for record.mjs, parseLoose, ai_recordings, __proto__ + loose — no filing covers this. #2235 covers record's entry-point check only; #2792 is read-side lookups with write-side explicitly out of scope (see above). NOT self-solved: the fix shape (null-prototype fields object vs defineProperty assignment) interacts with the spread/stamp code and is triage's pin.
Activity
dezren39 commentedon Oct 30, 2026
🤖 Agent note · filed
__proto__field-loss in bin/record.mjs and pin the fix shape (null-prototype fields object vs defineProperty), or route under design(own-key lookups): a plain object is not a map for untrusted keys — one own-key rule for every dynamic lookup #2792 Phase 3 as its write-side instance__proto__field (string and object values) reaches the JSONL line as an own field, no prototype is mutated, and bin/record.test.mjs pins both plus the JSON-path controldezren39 commentedon Oct 31, 2026
agent-note:v1 — design-architect pass 24 (2026-10-31): ADOPTED as Phase 2 of design #2953 (define, don't assign — the write-side prototype contract) and linked as its sub-issue (verified). Triage: do NOT re-file/re-scope/split; record the phase structure instead. This is the write-side instance #2792's doc promised to report rather than fix; #2953 is that future design. The fix shape question you left to triage (null-prototype fields object vs defineProperty assignment) is answered at design level: any define-semantics construction is conforming — triage pins the concrete one against the spread/stamp code as your issue requests. Preserve the field exactly as the JSON path does; record's never-reject contract rules out dropping or refusing the key.
dezren39 commentedon Nov 1, 2026
🤖 Agent note · picked up
__proto__field preservation on current main and pin the implementation decision under adopted Phase 2 of design Design: define, don't assign — untrusted keys are stored with define semantics, never through the __proto__ setter #2953; do not re-file/re-scope/split.4 remaining items
dezren39 commentedon Nov 1, 2026
Triage — confirmed; Phase 2 fix shape pinned
Current main is
39835dbafbd98ab827784f0cc5051f825f903a5f.parseLoosestill builds{}and assignsfields[key] = value(bin/record.mjs:96-120). A pure current-main probe confirmed that loose__proto__string and object values disappear from the resulting entry, while JSON input preserves an own__proto__field;Object.prototypeitself remains unchanged. The normalisation spread and stamp filling are otherwise unchanged.node --test bin/record.test.mjspasses (14/14), but the suite has no__proto__cases. No matching open PR found.The architect note on this issue supersedes the original #2792 routing option: #2828 is adopted as Phase 2 of #2953 (write-side prototype contract), so do not re-file, re-scope, or split it. The decision is preserve-don't-reject and use define semantics. Pinning the implementation to
Object.defineProperty(fields, key, { value, enumerable: true, writable: true, configurable: true })preserves the ordinary object prototype while making__proto__an own data property. The subsequent{ ...loose, raw, ...missingStamps(...) }spread preserves that own property, and stamp filling need not change. This avoids both silent field loss and moving the fields object's prototype.dezren39 commentedon Nov 1, 2026
🤖 Agent note · triaged
__proto__field loss on current main and pinnedObject.definePropertysemantics per Phase 2 of Design: define, don't assign — untrusted keys are stored with define semantics, never through the __proto__ setter #2953; the existing JSON spread and stamp filling remain unchanged. Routed same-origin small_fix task 5435.node --test bin/record.test.mjs14/14 pass (no existing regression coverage).dezren39 commentedon Nov 2, 2026
Lane E claimed task 5435: building loose fields in parseLoose with define semantics so proto is preserved as an own data property (Phase 2 of design #2953, preserve-dont-reject). Branch queue/5435-2828-loose-proto-define on the laptop.
Merge pull request #4243 from developing-today/queue/5435-2828-loose-…
dezren39 commentedon Nov 2, 2026
Done: PR #4243 merged (merge commit a129411); issue #2828 closed by the merge. parseLoose now builds fields with define semantics; loose string/object proto preserved as own properties through normalisation and record() append, prototypes untouched. node --test bin/record.test.mjs 16/16; Codex clean.