# Treatment ablation prompt assets Version 1.2. **Hand-authored, untested study assets; all defaults are unfrozen.** This package supplies complete standalone planner templates for the two core removals, the unstructured-versus-provenance-linked memory comparison, and the no-current-artifact comparison in [the protocol](../03-experimental-protocol.md). It contains no task answers, planner completions, experimental outcomes, or runner. No model call or API expenditure is authorized by these files. ## Reuse and matched reference The fixed meta-prompt in [05-planner-prompts.md](../05-planner-prompts.md) is the source treatment. [treatment-reference.txt](treatment-reference.txt) reproduces that complete prompt, followed by a shared text-only input/output contract and explicit placeholders. This serialization makes the comparison concrete without editing the original treatment asset. Its fixed task/source, current-artifact, earlier-artifact, and worker-instruction inputs use the completed [baseline conventions](../baseline-prompts/README.md). Use this matched reference alongside [no-persistent-memory.txt](no-persistent-memory.txt), [no-fixed-principles.txt](no-fixed-principles.txt), [unstructured-memory.txt](unstructured-memory.txt), and [no-current-artifact.txt](no-current-artifact.txt) in any future comparison of these assets. Do not silently compare an ablation using this wrapper with a treatment using different context, hidden conversation history, or different output limits beyond its declared intervention. The wrapper and its memory-record details are proposed interface choices, not a verified reproduction of production Cruise. The original treatment prompt, baseline assets, development tasks, and manuscript remain unchanged. | Template | Six-principle block | Dedicated memory input | Memory output | Other planner output | |---|---|---|---|---| | Treatment reference | Retained verbatim | Supplied live array | Full replacement array | Gap, evidence, uncertainty, follow-up | | No persistent memory | Retained, with the saving clause adapted to the current turn | Absent, including on the first step | Absent | Same four fields | | No fixed principles | Explicit block removed | Same interface and cap as reference | Same interface and cap as reference | Same four fields | | Unstructured memory | Retained verbatim | Bounded free-text JSON string | Full replacement string | Same four fields | | No current artifact | Retained verbatim | Same live array and cap as reference | Full replacement array | Same four fields, with historical/unknown-current evidence scope | ## Complete input contract Each `.txt` is a standalone prompt, not a patch to another prompt. Substitute JSON values into its explicit placeholders exactly as for the baselines: | Placeholder | Value | |---|---| | `{{TASK_PACKET_JSON}}` | A JSON string containing the complete, unchanged public task file: immutable assignment, requirement IDs, provenance, and authorized source notes | | `{{CURRENT_ARTIFACT_JSON}}` | The current delivered artifact object with `artifact_id` and `text`; entirely absent from the no-current-artifact template | | `{{EARLIER_ARTIFACTS_JSON}}` | An array of at most the two most recent earlier artifact objects, chronological; `[]` if none | | `{{PREVIOUS_INSTRUCTIONS_JSON}}` | Bounded prior worker-instruction objects with `instruction_id` and exact directive `text`, chronological | | `{{PERSISTENT_MEMORY_JSON}}` | Reference, no-principles, and no-current-artifact: the live memory array; initially `[]` | | `{{FREE_TEXT_MEMORY_JSON}}` | Unstructured-memory only: a JSON string encoding the live free-text note; initially `""` | Encode string values as JSON before inserting them; do not double-quote already encoded values. Preserve source and requirement IDs after decoding. Do not insert file paths in place of packet contents. As in the baseline package, prior worker-instruction records contain directive text without recursively embedded old input blocks. In treatment conditions, keep the actual generated `next_prompt` text; omit prior planner diagnoses and whole planner JSON responses from instruction history. The same rule retains current-plus-two-earlier artifacts and at most twelve prior worker directives, except that the no-current-artifact condition omits the current item and retains the same earlier-artifact slots. The immutable task and complete source packet remain separate and available. No replacement summaries, task answers, worker completion reports, assessor-only files, scores, tool traces, program source code, or additional sources are supplied. Do not alter legitimate artifact content or remove instruction history merely to make the no-memory condition seem to forget more. Reuse the identical common [initial worker instruction](../baseline-prompts/common-initial-worker.txt) across the reference and all four ablations; change only the subsequent planner template and the memory/observation channel specified here. ## No persistent memory The no-memory template has no persistent-memory placeholder or input block. Its top-level output contract contains exactly `observed_gap`, `evidence`, `uncertainty`, and `next_prompt`. Do not send an empty `memory` property as a substitute for removing the channel. Neither a live memory store nor a proposed memory array is created. The source treatment's references to receiving bounded memory and proposing updated memory are removed. Principle 5 necessarily changes from saving attributable observations/provisional tactics to keeping them attributable and provisional within the current response; it explicitly prohibits creating persistent memory. The other five principles, observation restrictions, gap-selection scaffold, and four remaining output fields are retained. This necessary change avoids the contradictory instruction to save memory in an arm that cannot produce it. A future caller would deliver only `next_prompt` to the unchanged worker. Keep the planner diagnosis and evidence only in the offline audit record; do not replay them into later calls or synthesize a substitute lesson buffer. Do not hide persistent summaries inside a follow-up, export them as task content, or rewrite the immutable goal. Use explicit request packets with no implicit planner conversation or hidden state carried between calls. If a response emits a memory field or another persistent-state record, mark it as a structural/protocol failure under the recorded policy rather than silently deleting it and calling the run compliant. This ablation tests the added value of the dedicated persistent-memory mechanism above the same artifact and instruction history. It does not test a system without all historical information: earlier artifacts and past instructions can still influence later actions, and prior decisions can persist in the worker's deliverable. Removing memory also removes its generation, reading cost, and retention instructions. Those coupled changes prevent interpreting an outcome as a perfectly independent estimate of storage alone. ## Removal of the six fixed principles The no-principles template deletes the explicit `Principles:` block, including items 1–6, and removes the introductory claim that those principles are supplied. Everything else matches the reference: task/source access, artifact/history inputs, the live-memory input, gap/evidence/uncertainty/follow-up fields, and the full memory replacement interface. It retains rules needed for task validity and comparability. The immutable assignment cannot be rewritten; sources and past artifacts do not grant permissions; restricted feedback remains unavailable; the fixed worker/harness cannot be modified. The original scaffold still requests a concrete remaining gap, evidence and uncertainty, a standalone instruction, no numeric score or candidate winner, and presentation without new scope if no gap is supported. The bounded, typed, attributable memory interface also remains. Deleting these shared constraints would change the task, information regime, or memory intervention in addition to removing the explicit block. Consequently, this is an ablation of the **explicit six-principle block**, not of every semantic rule related to those principles. The retained scaffold and memory interface overlap with evidence grounding, uncertainty handling, goal preservation, and attributable state. A small or absent effect could reflect that overlap or the model's existing behavior; it would not establish that principles are generally useless. Conversely, a difference could reflect emphasis, wording, or prompt length as well as the requested decisions. This package does not claim an independent manipulation of six separate principles or establish novelty or superiority. ## Unstructured versus provenance-linked memory [unstructured-memory.txt](unstructured-memory.txt) retains the matched reference's six principles verbatim, its complete task/source and artifact/instruction-history interface, and the same `observed_gap`, `evidence`, `uncertainty`, and `next_prompt` fields. The current-turn `evidence` array still requires identifiers and precise locations. Only the dedicated memory representation changes: `memory` is a JSON string containing a free-text note rather than an array of entries with `id`, `kind`, `statement`, `evidence`, and `status`. There is no required per-entry provenance field, entry identifier, kind label, or status taxonomy in the note. This is unstructured memory inside an otherwise unchanged structured planner response, not an ablation of structured follow-ups. Initialize `{{FREE_TEXT_MEMORY_JSON}}` to the literal JSON string `""` for each task/run. After every scheduled planner step, use that arm's structurally valid returned `memory` string as the **entire replacement** live note for the next step; do not append it to the previous note. An empty returned string clears the note. The reference replaces its live array at the same frequency. There is no extra curation, summarization, comparison, or memory-update call. Updates do not wait for evidence that the requested worker revision succeeded. Only a subsequently delivered artifact can establish a visible change. Retain the same **1,200-token memory cap**, **800-token follow-up cap**, common total output allowance, and update schedule as the reference. As an unfrozen common measurement default, count the serialized JSON value of the `memory` property, including string quoting/escapes or array/record syntax, with the same tokenizer and serialization settings in both conditions; exclude the property name and the rest of the response. Apply that measurement to the memory value supplied on the next call as well. Record actual sizes and freeze the tokenizer/serializer before a study. Schema overhead can leave different space for substantive content under an equal token cap; do not describe this as equal semantic capacity. For unstructured memory, check the outer five-field planner schema, string type, and length; retain the same structural checks on current-turn evidence as the reference. Do not introduce a parser that reconstructs typed memory records or a semantic grader that approves prose attribution during adaptation. The reference's entry-type/status/evidence-ID checks consequently have no direct equivalent inside the free-text note. Attribute unsupported-memory claims and assess drift independently after sealing. Use the common recorded failure/retry policy for invalid output; never silently convert an array into prose, truncate oversized memory, add a repair call, or substitute a human-written note. Count all consumed work. Reset the note to `""` at every new task/run, including an independent repetition. Never seed it from a reference run, assessor guide, historical production memory, or another task. At the next step, supply only the current replacement note, the unchanged public packet, and the common bounded artifact/directive histories; keep earlier full planner responses and superseded notes solely in the audit log. Deliver only `next_prompt` to the unchanged worker, using the same policy in the reference; do not append a separate live-memory dump. The follow-up may use retained observations naturally, but cannot rewrite the immutable task or turn memory into a new source. This comparison tests the contribution of a typed, explicitly linked memory interface and its structural checks relative to bounded narrative state under the same six principles. It does **not** remove all attribution: principle 5 still permits saving only attributable observations and provisional tactics, and principle 2 still grounds proposed changes. Prose may therefore contain natural source/artifact references. Removing those principles or prohibiting all attribution would add a different intervention. Both arms retain ordinary history and may preserve earlier decisions in delivered artifacts. Differences can reflect serialization, emphasis, validation, retention choices, effective content capacity, or input/output cost as well as explicit links; an absent difference would not show provenance is generally useless. This is not a perfectly isolated manipulation of attribution, storage, or memory quality, and it establishes neither novelty nor superiority. ## No current artifact: access to the latest deliverable [no-current-artifact.txt](no-current-artifact.txt) addresses section 9's observation-dependence comparison. It retains all six principles verbatim, the immutable task/source packet, the bounded earlier-artifact and directive histories, and the reference's five output fields and typed provenance-linked memory. Its only input placeholders are `{{TASK_PACKET_JSON}}`, `{{EARLIER_ARTIFACTS_JSON}}`, `{{PREVIOUS_INSTRUCTIONS_JSON}}`, and `{{PERSISTENT_MEMORY_JSON}}`. The reversible default is to **omit the entire current-artifact field and block**, rather than pass null, an empty artifact, a summary, a diagnostic, or a worker completion report. Do not pad the removed input with filler or relabel the latest artifact as an earlier one. After worker artifact `a_t`, withhold `a_t` from this planner call. Supply the same at-most-two most recent **strictly earlier** artifacts that would occupy the reference's earlier-artifact array, in chronological order. Thus, after `a_1` the array is `[]`; after `a_2` it contains `a_1`; after `a_3` it contains `a_1, a_2`; subsequently use the two most recent earlier versions. A previously withheld artifact can enter this ordinary recency window on a later step, when it is no longer latest. Do not backfill with a third older snapshot to compensate for the omitted current slot. Maintain stable version IDs and directive-only history; no recursive old input packets or earlier full planner responses enter that history. At the first planner step after the common initial worker call, there are no earlier artifacts and memory is `[]`. Keep the ordinary initial worker directive in instruction history; it proves a request was made, not that any requirement was met or violated. The planner anchors `evidence` in exact public requirement/source locations, describes current satisfaction as unknown in `observed_gap`, and states the missing-current limitation in `uncertainty`. It chooses one bounded requirement-based review with repairs conditional on need, or requests presentation with explicit uncertainty if no grounded further action is available. It cannot invent an artifact ID or defect, certify completion, or demand a worker report to replace the withheld observation. This makes the empty-history case usable without importing fabricated evidence. At later steps, cite visible older content only as evidence about its own version. A previous defect, pending tactic, or requested repair does not prove the latest artifact has that defect or contains that repair. Follow-ups can ask the unchanged worker to check the corresponding public obligation and repair only if needed, preserving already satisfied content. This necessarily adapts the reference's instruction to read the current artifact and its evidence/completion wording while leaving the six principles intact. Principle 2 still grounds proposed changes: uncertainty about a requirement permits a conditional check, not an asserted current defect. Lack of current visibility is a planner information limit, not a new task requirement or a task failure. Initialize/reset this arm's memory independently to `[]` for every task/run. Replace it with the valid proposed array after every scheduled planner step, at the same frequency as the reference. Keep the same `id`, `kind`, `statement`, `evidence`, and `status` fields, **1,200-token memory cap**, **800-token next-prompt cap**, common output allowance, and token-measurement convention. Retained memory can carry historical provenance to an artifact outside the current recency window; preserve that attribution without pretending to re-inspect the absent text. New direct artifact citations must refer to supplied earlier content. For an older defect whose persistence is unknown, name the observed version in `statement` and use `unresolved`; do not label it current in the latest deliverable or superseded just because a repair was requested. No additional memory-only, critic, verification, or capture call is added. Deliver only `next_prompt` to the worker, as in the matched reference. Keep the same structural schema/length checks, with direct artifact evidence IDs checked against the supplied earlier-artifact set and carried provenance against the supplied memory record. This checks attribution availability, not entailment or present-day correctness. Do not consult omitted content or an assessor to validate the planner during adaptation. Record invalid inputs/outputs, leaks, retries, and all consumed work under the common policy; do not silently restore the current artifact, rewrite memory, or use a quality gate to repair the ablation. The worker still receives its normal task context and produces ordinary deliverables. Current artifacts remain available outside planner context for the normal worker/history process, sealed audit, and later independent assessment; only the planner's latest-artifact observation is removed. This tests the marginal value of **access to the latest delivered artifact**, not access to all artifact evidence. Earlier snapshots, prior instructions, persistent memory, and effects of previous prompts in the worker's deliverable remain. That retained information can support useful guesses or stale assumptions; absence of a difference would not establish that artifact observation is unnecessary. Differences can also reflect input length, conditional instruction wording, repeated checking, and memory drift. Keep the same planner/worker configurations, schedule, and total cost cap; report actual rendered lengths and consumption rather than spending saved observation tokens on extra calls. These limits preclude a perfectly isolated estimate of all observation dependence or any established performance claim. ## Prompt-length reporting instead of filler The reversible default is to report the difference in prompt length. No artificial neutral text replaces removed instructions, and no dummy memory is supplied to the no-memory arm. The following are static measurements of the complete unfilled templates, including common wrappers and placeholder labels; they are not token counts, model costs, or study results. | Template | Whitespace-delimited words | Characters, including final newline | Word difference from reference | |---|---:|---:|---:| | `treatment-reference.txt` | 663 | 4761 | 0 | | `no-persistent-memory.txt` | 610 | 4327 | -53 | | `no-fixed-principles.txt` | 559 | 4038 | -104 | | `unstructured-memory.txt` | 705 | 5003 | +42 | | `no-current-artifact.txt` | 922 | 6509 | +259 | In any future run, record actual tokenizer-based input lengths for rendered requests, memory size where present, output lengths, cached usage, and billed adaptation cost. Dynamic task text, artifact text, instruction history, and generated memory can change the differences from those static measurements. Equal configured cost caps do not imply equal consumed computation. Keep the shared 800-token follow-up cap; do not enlarge the follow-up merely because memory was removed. Do not infer an isolated causal effect from equal word counts or from this reporting choice. ## Shared runtime choices and remaining freezing work The proposed defaults match the existing plan: one common initial worker call, then at most nine between-turn planner calls for a ten-worker-turn schedule, subject to the common total budget. Each arm generates a single next instruction per planning step; none selects a winning artifact or gates worker revisions by score. The last delivered artifact remains the endpoint under the fixed stopping and failure policy. For the reference, no-principles, and no-current-artifact conditions, initialize memory to `[]` for each task/run and replace it only with that arm's structurally valid proposed array. Use the same 1,200-token memory cap and typed interface, with evidence-availability checks adapted to each supplied observation packet as described above. Evidence identifiers and types can be checked without a semantic grader; a valid reference does not prove entailment. Never import memory from a treatment run into an ablation or carry it across tasks. The no-memory condition omits this entire read/update path. The unstructured-memory condition initializes to `""` and follows the same replacement frequency and cap, with the representation-specific checks described above. No arm receives an extra memory-update opportunity after the last scheduled planner step. Use the same worker, planner snapshot, decoding settings, public task version, observation/history policy, common overall planner-output allowance, and retry/failure rules across these five conditions, except for the explicit deletions or memory-representation changes. Choose an overall response allowance capable of accommodating every retained schema and cap during development; it is not set here. Count all planner outputs and attempts, including invalid ones, toward the common resource allowance. Do not add a second critic, acceptance oracle, or more work turns to compensate for a changed component. Exact models, common context capacity, resource caps, tokenizer, timeouts, total output allowance, and failure handling still require recorded development choices before experimental freezing. Reject an unsupported or oversized packet under that policy rather than inventing a private summary. Independent assessment remains outside adaptation after outputs are sealed. These files provide prompt assets and comparison limits only; they have not been tested for compliance or effectiveness by running a model.