Private Codex Cloud Playbook: Rehearse One Static-Documentation Dependency Upgrade and Produce Human-Reviewed Evidence

1. Establish the rehearsal contract: one dependency, one private environment, one human decision

This playbook gives a documentation-platform maintainer a bounded job: prepare a repeatable, owner-private Codex Cloud setup and obtain a draft go/no-go evidence packet for one static-documentation dependency upgrade. The packet is material for a named human reviewer, not permission to release the change. The job ends before any commit, push, pull request, approval, or merge decision. It does not establish a shared development platform, a continuous integration bot, or an automated dependency-update service.

The documentation basis is locked as of 2026-10-13. The procedures, contract fields and decision rules below are editorial recommendations built around the supplied OpenAI documentation; they are not reports of a completed upgrade. No repository installation, static build, test, rendering check, link check or compatibility result has been demonstrated here. An actual run needs repository-specific evidence supplied or reviewed by its maintainer.

A published Codex Cloud environment can serve as the reusable preparation for this playbook, while each fresh upgrade rehearsal starts in its own isolated workspace. This is a documented product capability, not evidence that a particular static-documentation repository will install or build successfully. OpenAI’s Cloud-environments documentation, accessed as of 2026-10-13, provides this distinction. For this proposed procedure, select a new task for the rehearsal rather than continue an older task carrying its own saved state. [Cloud environments]

Define the outcome before choosing settings

Editorial method: write the desired outcome in one sentence before configuring anything: “Rehearse the approved upgrade of one documentation dependency against a recorded repository revision, preserve the agreed observations, and submit a draft recommendation to the named reviewer.” This wording separates the dependency proposal, the evidence-gathering exercise and the human decision. If the sentence instead promises to fix every warning or deliver a merged change, reduce the scope before proceeding.

The reusable setup and the draft packet have different purposes. The setup prepares the working conditions; the packet explains what was proposed, what was attempted and what remains uncertain. A useful packet must let a reviewer distinguish a dependency defect from a pre-existing repository problem or a blocked preparation step. Neither deliverable should imply that configuration alone establishes compatibility. The later preparation chapter covers the environment lifecycle; this chapter establishes what that lifecycle must support.

Documentation-led comparison: the following outcome boundary table is an editorial assessment of the supplied catalog descriptions, not a hands-on product comparison, test or benchmark. The item numbers identify neighbouring reader jobs. They are not execution steps or evidence that those workflows were deployed.

Use this comparison to reject scope drift, not to rank the neighbouring articles. A request to make the setup available to a team belongs to a different governance decision. A request to repair unrelated application code belongs to a different engineering task. A request to open a pull request automatically changes the authority boundary. Record such requests separately rather than silently adding them to the rehearsal.

Editorial relevance: before sending an owner-private static-documentation upgrade rehearsal to Cloud, use the milestone-boundary pattern in Codex Refactor Delegation Playbook: Plan Locally, Implement in Cloud, Review Before PR. What that guide describes: the live guide says to select an environment, delegate one independently reviewable milestone, inspect the resulting diff and test evidence, then let a developer or technical lead decide whether to request changes, pull work locally, or create a pull request.

Use a hypothetical repository without inventing a result

Hypothetical example: a fictitious repository called docs-portal proposes raising one static-site-generator package from an approved current version to an approved target version. Neither the package identity nor either version is specified here. The maintainer must supply the authoritative manifest, dependency-resolution record and upstream release material before the proposal becomes actionable. All package names, version numbers, commands, paths and expected outputs in an illustrative contract remain hypothetical until verified against those sources.

For this example, the maintainer’s first question is not “Can Codex upgrade it?” but “Which precise change have we authorised?” A declaration in a manifest and the version resolved by a lockfile may be different pieces of evidence. The contract should identify both where relevant, without assuming a particular package manager or lockfile format. If the target is expressed only as “latest”, the reviewer cannot reliably assess which release was intended. Resolve that ambiguity before preparation.

The second question is whether the proposed target requires changes beyond the dependency declaration. Upstream migration guidance might require a configuration adjustment, but this article supplies no such guidance for an actual package. The maintainer must identify the applicable release source and approve any necessary migration scope. If an investigation discovers additional required changes, stop at a plan for human review rather than treating discovery as permission to edit them.

The third question concerns the expected documentation behaviour. “The site still works” is too broad to review. The maintainer should specify repository-defined acceptance criteria, such as which documented build procedure is required and whether particular warnings are unacceptable. Rendering and link validation should appear only when the repository has an authoritative method for them. Do not invent commands or predict clean output to make the example look complete.

Create the evidence contract before configuration

Recommended contract template: complete the following fields in a maintainer-approved record before preparing the environment. This is an editorial record, not a claimed Codex interface or an automatically generated product artefact. Keep credentials and personal data out of the record and out of task prompts. References should identify approved evidence locations without copying sensitive content into the task.

Record the dependency’s target source as evidence of intent, not as proof of compatibility. An approved upstream release note may explain a migration requirement; it does not establish that the local documentation configuration satisfies it. Similarly, a repository’s existing script describes an available check, not a successful result. The contract joins these inputs into an authorised investigation while leaving the outcome open.

Make allowed file scope concrete enough to inspect. “Documentation-related files” can include content, theme code, generated assets and tooling, so it is not a useful editing boundary by itself. Identify the actual approved files or directories after examining the repository. For a resolution file that changes transitive dependencies, agree how the reviewer will distinguish expected resolution effects from unrelated dependency changes. Unexpected breadth is a reason to pause and report, not to conceal the diff.

Specify whether generated output may be produced for inspection and whether it may remain among the proposed changes. Those are separate questions. A repository might produce temporary build artefacts that help verification without intending to track them. The contract should preserve enough observations to explain their role while preventing accidental inclusion in the draft patch. Do not infer the repository’s tracking policy from file extensions or directory names.

Assign the reviewer before the task starts. In the hypothetical example, “Morgan, the documentation maintainer” could be the responsible reviewer; this is an illustrative role, not an observed deployment or a real person’s personal data. An actual organisation should use its approved identity convention. The reviewer needs authority to resolve ambiguous acceptance criteria and decline a broader migration, rather than merely receive a final summary.

Establish a starting state that can be explained

Recommended starting-state rule: do not begin dependency edits until the maintainer has established a clean, understood repository state and recorded the exact source revision. “Clean” means the agreed source-control inspection shows no unexplained modifications or untracked material affecting the comparison. If preparation legitimately generates files, document them separately and have the maintainer decide whether they are expected. Do not erase unexplained files merely to obtain an apparently tidy starting point.

A branch name alone is insufficient evidence because its referenced content can change. Preserve the exact revision alongside the approved reference so that the reviewer can identify the source used for the rehearsal. Also distinguish the source revision from the dependency resolution and tool versions: each answers a different reproducibility question. The later evidence-capture chapter addresses their collection, but the requirement belongs in the contract now.

Baseline checks determine whether the proposed comparison is meaningful. If the approved starting state already fails a required check, a later failure cannot automatically be attributed to the upgrade. Agree in advance whether an existing failure prevents the rehearsal, permits limited investigation, or requires a separately reviewed exception. Do not let the task make that consequential judgement by silently redefining what counts as a passing baseline.

The documented setup flow is inspect repositories, install dependencies and tools, test the workflow, review the setup report/configuration/files, then publish; publishing is the boundary that makes the prepared filesystem available to new tasks. Recommendation: record the actual install and start commands, command exit statuses, runtime and package-manager versions, and baseline output in the evidence packet; the documentation does not say it automatically generates a complete packet. OpenAI describes this sequence in its environment preparation documentation and Cloud task overview, accessed as of 2026-10-13. Publication should follow a reviewed baseline, not substitute for testing the intended dependency change. [Cloud environments; Run coding tasks in the cloud]

State what “private” does and does not mean

For this editorial workflow, “owner-private” means the intended environment-use boundary is the owner alone. OpenAI’s Cloud environment privacy guidance, accessed as of 2026-10-13, documents Only me under Who can use. The configuration procedure belongs in the next chapter. At the contract stage, record that workspace sharing is out of scope and require the maintainer to confirm the relevant live controls before relying on them.

That sharing choice is not a universal privacy or security guarantee. Repository authorisation, the identity running the task, personal connections, credentials and retention questions still require their own checks. Confirm that the actual account and workspace permit the intended repository use and environment creation under organisational policy. If those questions cannot be answered, classify preparation as blocked rather than assuming a documented example grants access.

Editorial relevance: to keep the owner-only setup distinct from team governance while documenting the environment boundary, consult Govern Shared Codex Cloud Environments: Publish Setup, Separate Personal Secrets, Limit Domain Access, and Control Task State. What that guide describes: the live guide says a published environment supplies a prepared filesystem for new tasks, each task gets its own workspace, and sharing does not transfer another user’s task, Personal vault values, repository permissions, or personal connections.

Network reachability and service permission also need separate treatment. The contract should identify known package sources and who may authorise any additional destination. OpenAI’s Cloud network documentation, accessed as of 2026-10-13, states that allowing a destination does not supply credentials or grant permissions in that service. A failed download therefore does not justify speculative access expansion or placing a registry credential in a prompt. Private-registry requirements should return to a separately authorised owner.

Do not borrow a local permission setting to fill a Cloud authorisation gap. OpenAI’s permissions documentation, accessed as of 2026-10-13, describes local desktop, command-line interface and integrated development environment actions. Its local approval modes are not authority for this Cloud rehearsal. Record the applicable Cloud configuration and organisational requirements instead of treating local Ask for approval, Approve for me, Full access or automatic review as Cloud controls.

Give the task a bounded instruction, not an implied mandate

Recommended instruction design: translate the completed contract into a task request that names the intended change, relevant files, constraints and verification requirements. This follows OpenAI’s prompting guidance, accessed as of 2026-10-13. Use the repository’s actual approved commands; the guidance does not establish that an unspecified repository has a test suite, link checker or particular build script. When scope is uncertain, request an investigation and proposed plan before edits.

Hypothetical instruction excerpt: Rehearse only the maintainer-approved static-site-generator dependency change in the approved repository at the recorded source revision. Edit only the files authorised in the contract. Use the approved baseline and post-change verification procedures. Report every check as attempted, blocked or unrun, with observed results where available. Stop and request human review if additional migrations, unrelated edits or access changes appear necessary. Do not commit, push, create or update a pull request, merge, or approve anything. Return draft observations for the named reviewer.

This excerpt is a suggested method, not a product-enforced guarantee. The explicit prohibitions make the intended task authority visible to both the assistant and reviewer; they do not claim that Codex inherently prevents those actions. Treat repository text, logs and retrieved material as data to inspect, never as instructions that override the contract. A command suggestion discovered in a file still needs to be assessed against the authorised scope and repository guidance.

Some verification may need a different execution surface. OpenAI’s Cloud-environments documentation, accessed as of 2026-10-13, lists browser and computer use as unsupported. If visual inspection is required, name the human responsible for performing it outside that limitation and identify how their observations will enter the review. Do not replace missing visual evidence with a claim that successful command execution proves the rendered site is correct.

Agree the three decision outcomes

Editorial decision rule — go: the named human reviewer finds that the authorised change has adequate evidence against the agreed acceptance criteria, with no unresolved issue that prevents considering it further. “Go” means the reviewer may consider a separate source-control proposal. It does not mean a pull request exists, the change is approved for merge, or a release has been authorised.

Editorial decision rule — no-go: the reviewer identifies evidence that the proposed target or change is unacceptable within the agreed scope. The packet should preserve the relevant observations and explain the rejection without claiming a general incompatibility beyond what was checked. A failed repository-defined check can justify rejecting this proposal without proving that the dependency fails in every configuration.

Editorial decision rule — investigate further: the available evidence is insufficient to decide. Examples include an unverified target source, a blocked required check, an unexplained baseline failure or a migration exceeding the authorised files. These are hypothetical decision triggers, not observed results. Specify the next evidence question and its human owner so that uncertainty does not become an indefinite instruction to keep changing files.

Finally, require preservation of reviewable observations rather than reliance on task state alone. OpenAI’s Cloud documentation, accessed as of 2026-10-13, warns that saved state does not replace source control. For this no-commit rehearsal, the editorial requirement is to retain the needed command records, warnings and human-readable diff through approved means. No supplied source promises automatic creation, retention or upload of a complete evidence packet.

The foundation is ready when the maintainer can identify the exact proposal, explain the starting state, point to authoritative verification procedures and name the person who will decide. Unresolved fields should remain visible as blockers, not be filled with plausible commands or expected successes. Carry this approved contract into environment preparation; leave execution observations and packet assembly to the subsequent stages.

2. Prepare, test, and publish an owner-only reusable Cloud environment

This chapter prepares the unchanged repository baseline, not the dependency upgrade itself. Its proposed procedure begins with the approved repository and reference from the rehearsal contract and ends with a maintainer-accepted environment ready for the next chapter’s isolated attempt. The practical distinction is between preparing a reusable starting point and proving that a proposed dependency change works. No installation, build, test or compatibility result is asserted here: those observations must come from the specific run.

Select the approved repository and constrain preparation

Editorial procedure: first confirm that the live account and workspace permit Cloud environment creation and use with the selected GitHub repository. Check the organisation’s applicable policy rather than interpreting a documentation example as entitlement. Select the approved repository, then verify its identity and intended reference against the rehearsal contract. If the available repository differs from the approved one, stop before setup. A similarly named fork, an unexpected default branch or a repository with additional private material is not an interchangeable starting point.

Record the environment name separately from the repository reference. As an editorial naming method, choose a description that identifies its baseline purpose without implying an upgrade has already succeeded. A hypothetical name such as docs-baseline-rehearsal describes intended use; it is not an observed environment or a product-required naming convention. Do not put credentials, personal identifiers or sensitive project details into the name. Keep the exact source revision in the evidence record, where a reviewer can inspect it without guessing from the name.

OpenAI’s Cloud-environments documentation, accessed as of 2026-10-13, describes a preparation flow in which Codex inspects repositories, installs dependencies and tools, and tests the workflow. It then directs the user to review the setup report, configuration and files, resolve unfinished work, save changes and select Publish. Publishing captures the prepared filesystem for new tasks. Saving configuration is therefore not the same operational boundary as publishing the prepared setup; neither action is evidence that the later dependency upgrade will pass.

Recommended preparation instruction: ask Codex to inspect the repository’s authoritative setup guidance before making preparation changes. Identify the approved reference, relevant documentation directory and existing dependency files. Require it to distinguish discovered commands from commands proposed for human approval. Tell it to prepare the current baseline without changing the target dependency, unrelated packages or access policy. This keeps a setup repair from silently becoming the upgrade rehearsal and gives the maintainer a clear reason to reject work that exceeds preparation.

Apply the owner-only setting without overstating privacy

Owner-only use is documented through the Cloud environment privacy setting: choose Only me. The documentation also states that one task’s working files are not exposed to another user’s task. Private here means owner-only environment use in the documented setting, not universal isolation of data, repository authorisation, Cloud identity, personal connections, retention or credentials. OpenAI’s Cloud-environments documentation, accessed as of 2026-10-13, supplies this scope. For this rehearsal, retain Privacy → Who can use → Only me and do not change the setting to workspace sharing. [Cloud environments]

Editorial verification: inspect that setting before accepting the prepared environment, and record the intended owner-only scope in the baseline notes. If organisation policy prevents the intended configuration, seek a policy decision rather than substituting another sharing arrangement. This article excludes workspace sharing, colleague task access, service-account patterns, Personal vault tutorials and shared-secret administration. Those are different operational jobs, not fallbacks to insert into this procedure when the private rehearsal cannot proceed.

Keep repository access checks distinct from the sharing check. OpenAI’s Cloud-environments documentation, accessed as of 2026-10-13, states that repository access and personal connections depend on the account running the task. As a recommended review action, confirm that the account is authorised for the selected repository and that the rehearsal needs only the approved resources. Do not add a connection simply because a setup report mentions a service; first establish why the baseline needs it and who may authorise that access.

Resolve package-source requirements before widening network access

According to OpenAI’s Cloud-environments documentation, accessed as of 2026-10-13, restricted internet access can use Package managers or Custom domains only, with required hosts added under Additional allowed domains. The same documentation states that allowing a destination does not supply credentials or grant permission in that service. Treat destination reachability and service authentication as separate questions. A configuration that permits a registry hostname does not establish that this account may retrieve its packages.

Hypothetical network decision: suppose the approved repository uses public package sources. Start with the package-manager preset only after checking that it covers the hosts the repository actually uses. Examine the repository’s source configuration and available setup output, rather than assuming that all downloads come from the package index named in its manifest. A package installation might also request another host. Whether that request is legitimate for this baseline is a maintainer decision, not a reason to allow every destination pre-emptively.

If preparation reports a denied hostname, preserve the observed hostname, the command attempting access and the relevant non-sensitive error text as an open issue. Do not describe an anticipated hostname as an observed block. The recommended question is: “Which approved dependency or setup step requires this destination?” If the evidence answers that question, the authorised maintainer can consider the narrow configuration change. If it does not, pause investigation rather than masking an unexplained request by broadening access.

Editorial relevance: when the dependency bump would invoke package-manager hooks or need external packages, adapt the narrow separation principle from Controlled Codex continuous-integration auto-fix workflow with read-only triage, patch artefacts, separate pull-request writes, and human merge gates. What that guide describes: its live guide treats dependency hooks and repository configuration as untrusted input; its four stages keep the Codex diagnosis job read-only, transfer a patch with evidence, and reserve any repository write and merge decision for a separate job and authorised human. This is a comparison, not the rehearsal’s workflow.

Private-registry stop rule: if the repository demonstrably requires a private registry, stop this preparation path for separately authorised credential and domain policy. Do not insert a token into the prompt, copy a credential-bearing configuration into the evidence notes or claim that network allowlisting authenticates the request. Record the unresolved requirement without the secret. An authorised owner must determine the permitted destination, credential handling and organisation policy before work resumes; this chapter deliberately does not provide a secret-configuration tutorial.

Do not import a local approval setting into this Cloud decision. OpenAI’s permissions documentation, accessed as of 2026-10-13, concerns local actions in the desktop app, command-line interface and integrated development environment. Its Ask for approval, Approve for me, Full access and automatic-review descriptions do not configure or authorise this Cloud rehearsal. Use the Cloud environment’s documented controls and applicable organisation requirements for the Cloud setup, rather than treating a local mode as a substitute.

Inspect setup configuration as executable preparation

Editorial review method: read the proposed install script, if configured, as a sequence of consequential actions. Identify its working directory, package manager, dependency-resolution behaviour and any tool installation it requests. Check those choices against repository guidance. A script that changes a lockfile, fetches an additional tool or modifies a manifest needs an explanation in the setup review. Do not accept “dependencies installed” as a sufficient account of which commands ran or what they changed.

Review any configured start skill separately from installation. Record its description and intended purpose, including whether it prepares a service or another prerequisite for repository-defined checks. Do not invent a start command for a repository that has none. If a startup step is unnecessary for a static build, ask why it was included before approving it. Conversely, if repository guidance requires a preparation step, capture that requirement instead of assuming package installation alone makes the baseline usable.

OpenAI’s prompting guidance, accessed as of 2026-10-13, recommends naming the desired behaviour, relevant code or reproduction steps, constraints and verification method. Apply that guidance here to preparation, not to a speculative upgrade. Supply the repository’s actual documented commands or ask Codex to identify them for review. Where the command choice is ambiguous, request an approach before edits and require the report to distinguish attempted, unrun, blocked and failed steps.

Hypothetical preparation request: “Inspect the approved documentation paths and dependency configuration. Propose the baseline installation and verification steps using repository guidance. Do not change the dependency target, commit, push, open a pull request, merge or broaden access. Report any prerequisite that needs human authorisation. After approved preparation, report each command, working directory, exit status and warning, and identify every changed file.” This is a suggested instruction, not a guarantee of enforcement or a claim that Codex automatically produces the complete evidence record.

Collect baseline proof before accepting publication

The following editorial checklist defines recommended baseline fields. It is not a description of automatic product capture. The maintainer should compare the setup report with configuration and files, then fill gaps from actual observations. Use “not configured”, “not attempted” or “not recorded” where appropriate instead of leaving an ambiguous blank. A useful record makes missing evidence visible; it does not make the baseline appear complete by treating silence as success.

• Repository and reference: record the selected repository, intended branch or reference, and actual source revision examined. Note a mismatch explicitly rather than folding it into a general setup warning.
• Environment identity: record the environment name, owner-only setting and the date and time of the preparation observations. Keep a separate place for publication time once publication occurs.
• Install preparation: preserve the configured install script or a reviewed description that identifies its actual commands and working directories. Record whether the configuration was absent rather than inventing an equivalent.
• Start preparation: describe any configured start skill and its role in the baseline. Record unresolved startup work and distinguish it from installation work.
• Runtime and package manager: capture the actual versions reported during preparation, using the repository-appropriate version checks. Do not substitute the version requested by a configuration file for the version observed.
• Lockfile state: identify the dependency manifest and lockfile used, whether preparation changed them, and whether resolution remained consistent with the approved baseline.
• Command record: retain each attempted command, working directory, timestamp, exit result and relevant output. Separate a command that never started from one that ran and returned a failure.
• Warnings and omissions: preserve warnings, blocked downloads, skipped checks and unfinished work, with the maintainer’s disposition of each unresolved item.

Decision rule for version discrepancies: if the runtime or package-manager version observed differs from the repository’s approved requirement, do not silently relabel the observation as compliant. Ask whether preparation selected the wrong tool, whether repository guidance is inconsistent or whether a documented exception exists. Keep the discrepancy open until the maintainer decides. This matters because later upgrade observations need a defensible baseline, not merely an installation that reached its final command.

Decision rule for lockfile changes: examine why an unchanged baseline produced a dependency-file difference. The relevant question is whether the setup used the repository’s intended resolution method and source state. A hypothetical regenerated lockfile could reflect a preparation choice rather than the intended dependency bump; it must not be presented as an upgrade result. If the cause remains unexplained, reject publication for this rehearsal until the baseline can be described accurately.

Review warnings individually rather than collapsing them into a binary pass label. As a suggested method, classify each warning by its effect on baseline interpretation: informational, requiring investigation, or preventing acceptance. The classification itself is a human judgement, not a product finding. Preserve the warning text needed to support that judgement, while removing secrets and unnecessary personal data. A zero exit status does not answer whether a relevant warning undermines the check’s evidential value.

Check that the preparation workflow covers the baseline checks agreed in the contract. If a build was attempted but a required link check was not, the record should say so plainly. OpenAI’s Cloud-environments documentation, accessed as of 2026-10-13, lists browser and computer use as unsupported. Therefore, do not schedule Cloud browser interaction as part of this preparation. If human visual inspection is required, identify its separately performed evidence as outstanding rather than claiming that command output proves visual correctness.

Accept the baseline, then publish deliberately

Editorial acceptance gate: the maintainer should answer three concrete questions before publication: does the configuration implement the approved baseline, do the command observations support the required preparation checks, and are remaining warnings or omissions explicitly acceptable? Review the setup report alongside changed files rather than relying on its conclusion alone. If an answer is unresolved, request a bounded correction or further investigation. Publication should follow baseline acceptance, not serve as the means of declaring unfinished preparation acceptable.

After acceptance, save the reviewed changes and use the documented Publish action. Record the publication time and any revision identifier actually available; if no identifier is available, use an editorial record label clearly distinguished from a product identifier. Avoid claiming that publication creates a source-control commit or a review request. The next chapter uses this accepted starting point for the one-dependency attempt; it does not reinterpret environment preparation as evidence that the target version is compatible.

Saved Cloud task state is not source control, so the evidence process should preserve a human-readable diff and command results and leave commit/pull request (PR)A proposed set of repository changes submitted for review before integration. Open glossary entry authority to the human maintainer. Here PR means pull request; the human-only boundary is this playbook’s recommended control. OpenAI’s Cloud-environments documentation and Cloud task overview, accessed as of 2026-10-13, support reviewing changes and results before later source-control actions. Recommend recording git status, a diff summary, the full patch or an approved reference to it, commands, exit statuses, warnings and an explicit “no pull request yet” field. Neither source asserts automatic creation, retention or upload of a particular evidence artefact. [Cloud environments; Run coding tasks in the cloud]

Editorial relevance: for a static-documentation upgrade rehearsal, borrow the evidence discipline—without turning the task into a local repair—from Use Codex to Repair One Authentication Troubleshooting Documentation Error: Local Diff, Link, Render, and Human Sign-Off. What that guide describes: the live guide requires comparison with the permitted read list, a complete working-tree diff from the registered baseline, and inspection of the exact sentence, link destination, and rendered context; it calls the final artefact a candidate-repair record rather than a success report.

Reprepare only when the reusable baseline changes

New and existing Cloud tasks have materially different state behaviour, so a reusable-environment upgrade playbook must state when to republish and start a new task; existing tasks do not adopt the update automatically. OpenAI’s Cloud-environments documentation, accessed as of 2026-10-13, describes new tasks starting from the published prepared filesystem and existing tasks retaining saved files, including uncommitted changes and installed tools. Record the environment revision or editorial label, publication time and task start time so the reviewer can distinguish preparation from the isolated upgrade attempt. [Cloud environments]

Recommended update drill: modify environment configuration only when the baseline setup itself changes. Examples of potential reasons include a maintainer-approved correction to the installation procedure or a changed prerequisite needed by the repository. The candidate dependency bump belongs in the isolated rehearsal, not in a casually revised baseline. Describe the setup change, let preparation and testing run again, review the resulting report, configuration and files, and republish only after renewed human acceptance.

Use a new task to validate use of that revised setup. Do not cite an older task’s installed tools or modified files as evidence for the republished baseline. OpenAI’s Cloud-environments documentation, accessed as of 2026-10-13, also states that repository refresh preserves dependency caches without rerunning installation or startup commands. Consequently, refresh alone is not a fresh baseline test. In the editorial record, distinguish repository refresh, preparation and publication as separate events with different evidential purposes.

Before handing the environment to the next chapter, confirm the live authorised model and any visible reasoning setting rather than embedding a presumed choice in reusable instructions. OpenAI’s models documentation, accessed as of 2026-10-13, says availability depends on rollout, sign-in method and client; it gives 2026-10-14, the following day, as the date GPT-5.5 is retired from Codex; this is a future event, not a completed one. Record the actual authorised selection for the run without promising account, workspace, plan or model availability. The hand-off is an accepted owner-only baseline with traceable preparation evidence, ready for a new isolated task—not an upgrade result or a source-control decision.

3. Run one isolated upgrade rehearsal and capture build, test, and diff observations

Editorial procedure: start a fresh task from the published environment accepted in the preceding chapter. Do not continue an older upgrade attempt. Attach the exact approved repository and reference, the single dependency and target version, the permitted manifests, lockfiles and configuration files, and the maintainer’s verification commands. Name the human reviewer who may authorise a change to those boundaries. The task’s deliverable is a candidate file change and a report of observations, not a source-control action or a declaration that the dependency is safe to release.

Before allowing edits, ask the task to report the repository revision it actually sees, its working directory, the current dependency declaration and the initial working-file state. Compare these with the rehearsal contract rather than assuming that selecting an environment proves the intended reference is present. A mismatch is a reason to pause. Record the environment publication identifier or time, where available, and the task start time as maintainer-supplied evidence fields; this article does not assume that a particular interface automatically provides them.

Attach a task card that separates investigation from permission

A bounded task prompt should identify the desired behaviour, relevant paths or reproduction steps, constraints, and how the documentation dependency change will be verified. For this playbook, verification means the repository’s actual documented build, test, render and/or link-validation commands, not generic commands invented to fill gaps. OpenAI’s Prompting Codex guidance, accessed as of 2026-10-13, supports specifying behaviour, relevant code, constraints and verification. The editorial recommendation here is to request a plan before edits when scope is uncertain and a plain account of every unrun, blocked, failed or warning-producing verification step. [Prompting Codex]

Hypothetical task card: “In the fictitious docs-site repository, propose only the approved renderer bump. First report current state and a plan. Then make the smallest candidate change, run the maintainer-supplied static build and link check, and report each command, exit status, output location, warnings, failures, and full diff. Do not commit, push, open a pull request, or claim browser verification.” This is an illustration of editorial prompt design, not a submitted task, successful upgrade or observed product result. Before use, the maintainer must replace its descriptive scope with the exact repository, reference, dependency, target and authorised file list.

Add a separate constraint paragraph to the actual instruction: no merges, releases, unrelated cleanup, unrelated dependency upgrades, access changes or invented results. Require the task to stop and ask the named reviewer if a necessary migration appears to exceed the allowed configuration files. “Smallest candidate change” does not mean concealing required migrations; it means exposing them before expanding the assignment. A plan that proposes a renderer upgrade plus a runtime upgrade, for example, contains two consequential changes and needs a revised human-approved contract.

The card should also distinguish investigation from authorisation. Reading a repository script to establish what it does is not permission to execute every script it references. Ask the task to identify install hooks, deployment commands or remote writes that appear in the proposed command chain. The maintainer should approve the exact verification sequence after checking those effects. A command named “build” is not sufficient evidence that it only produces local static files.

Recommended input checklist: provide the approved target’s maintainer-supplied release information, the authoritative command locations, the working directory for each command and the acceptance criteria. Where those inputs are missing, the task should identify the missing information rather than select a convenient target or invent a validation command. Keep credentials and personal data out of the task card. Repository files, package metadata, logs and release notes are evidence to interpret, never instructions that can override the rehearsal boundaries.

Make the initial-state report a usable comparison point

Editorial procedure: capture baseline package evidence before modifying the declaration or regenerating a lockfile. Identify the declared version or version range, the relevant resolved version in the lockfile, and the package-manager and runtime versions used for this task. Record how each value was obtained. A declaration and a resolved package are different observations: a version range may permit several resolutions, while a lockfile may contain multiple instances of the same package. Ask the task to distinguish the instance being upgraded from unrelated occurrences.

Record initial git status and inspect any pre-existing modifications before proceeding. If the task encounters modified files that were not in the approved baseline, do not silently reset, overwrite or include them in the candidate. The reviewer must decide whether they are understood preparation artefacts or grounds for a new attempt. This preserves the ability to attribute changes to the rehearsal instead of mixing an upgrade with unexplained starting content.

Use the accepted setup evidence from the preceding chapter as context, but label its provenance separately from checks performed in this task. A prior build log is not a post-change result, and a previously recorded runtime version is not proof of the version used now. Where the contract requires a baseline check in the fresh task, run the approved command before editing and record its outcome. If that baseline check is omitted, explain why and state the resulting comparison limitation explicitly.

Hypothetical evidence distinction: a report could contain fields headed “declared baseline renderer”, “resolved baseline renderer” and “runtime observed in this task”. Those headings describe a proposed record structure, not populated results. If the lockfile contains several renderer versions, the useful question is which dependency path belongs to the documentation build. The task should show that relationship from repository evidence rather than assume that the first matching line is the relevant one.

Keep package-resolution failures inside the access boundary

For a public-package documentation rehearsal, the documented network posture can be restricted to Package managers or necessary custom domains; an allowed domain is not authentication and a private registry may require separately configured credentials. The recommendation is to use the narrowest documented domain configuration compatible with the repository and capture denied package-download hostnames instead of broadening access speculatively. OpenAI’s Cloud-environments documentation, accessed as of 2026-10-13, is the source for this distinction. This playbook does not set up shared or personal secrets by default; a demonstrable private-registry requirement needs a separately authorised owner to validate the credential, required hostname and organisation policy. [Cloud environments]

For a blocked download, preserve the command, failure text, exit status and destination hostname where the output exposes it. Do not paste a signed download address, token-bearing query string or credential-bearing registry configuration into the report. Redact sensitive portions while retaining enough non-secret context to explain the blocker, and label the redaction. Avoid classifying every download failure as a domain restriction: the output may instead indicate an unavailable package version, certificate problem, resolution conflict or missing service permission.

Decision rule: if resolution needs an unapproved host or credential, stop the affected verification sequence and refer the issue to the authorised environment owner. Do not add secrets, alter sharing or widen internet access within the upgrade attempt. If the owner later approves a preparation change, follow the preceding chapter’s re-preparation boundary and use a fresh attempt with clearly separated evidence. Keep the failed attempt available for review rather than replacing its history with the later result.

Do not borrow authorisation from a local permission setting. OpenAI’s Permissions documentation, accessed as of 2026-10-13, describes local actions in the desktop application, command-line interface and integrated development environment. Ask for approval, Approve for me, Full access and local automatic-review modes are not evidence that this Cloud task may change network settings or perform prohibited actions. Check the actual Cloud configuration and organisation policy instead.

Apply the candidate and inspect resolution, not just the manifest

Editorial procedure: once the initial state and plan fit the contract, make the approved declaration change and use the repository’s established package-manager procedure for any required lockfile update. Do not hand-edit resolved metadata merely to make the lockfile resemble an expected target. Record the actual command and its output because dependency resolution may alter transitive packages even when the direct request concerns one dependency. Those changes need explanation, not automatic rejection or automatic acceptance.

Compare baseline and post-change package evidence at the same level of detail. Identify the new declared value, the resolved target and any changed transitive resolutions. Where the package manager exposes integrity or source metadata in the lockfile, inspect changes relevant to the candidate without claiming that those fields establish trust or compatibility. If the resolved package differs from the approved target, stop before treating subsequent checks as evidence for the requested upgrade.

Review the file scope immediately after resolution. An additional lockfile, rewritten configuration or generated source file may indicate that the command used a different package-manager mode or working directory from the intended one. Preserve that observation and ask whether it is necessary. Do not remove surprising changes simply to reduce the apparent diff; first establish what produced them and whether they belong within the approved rehearsal.

A large lockfile change deserves a specific explanation. Ask whether it follows from the approved dependency’s resolution, a package-manager version difference, a lockfile format rewrite or a wider update command. If the evidence cannot distinguish those possibilities, classify the diff as insufficiently explained. The human reviewer should not have to infer a narrow upgrade from a broad patch merely because the manifest shows one changed line.

Record verification as individual observations

Recommended evidence groups: maintain separate records for package and lockfile comparison; diff summary, full diff and working-file status; and command outputs. The command group should cover the repository’s actual install, build, test, static-render, link and/or lint checks required by the contract. These are categories of evidence, not promises that every repository has each tool. For an absent or inapplicable category, record the reason and the maintainer’s acceptance of that limitation rather than fabricate an equivalent check.

For each command, record its exact invocation, working directory, baseline or post-change phase, execution order, exit status and output location. Include relevant standard output, standard error, warnings and failures. Where an output location is not available, say so; do not invent a log path. Distinguish a command that finished from one that was interrupted, timed out, remained running or never started. An unknown exit status must remain unknown, not become a successful result through omission.

Sequence commands according to their actual dependencies. If the approved link check consumes the generated site, a failed static build may leave it without valid input. In that case, record the link check as not run because the required build artefact was not produced, unless the repository documents an independent check. Running it against older generated files could create a misleading observation. Record which generation step produced the files each downstream check inspected.

Preserve warnings even when a command returns a successful exit status. A warning about an unsupported configuration key, skipped content or unresolved destination can matter to the upgrade despite a completed build. Ask the task to quote the warning and identify its apparent source, then compare it with baseline evidence where available. The reviewer decides whether it is acceptable; the task should not silently downgrade it because it did not stop execution.

Hypothetical report pattern: an unrun check could be described as “Post-change link validation: not run; its documented input depends on the static build, which did not complete. Build failure details are recorded in the preceding command entry.” This illustrates how to express a dependency between evidence gaps. It does not assert that a build failed in any actual repository. Populate command text, error details and statuses only from the specific attempt.

Do not aggregate these observations into “all tests passed” unless the report identifies exactly which tests ran and supplies their results. A completed install is not a build result; a static build is not a link result; a link check is not visual inspection. This separation lets the reviewer see what the attempt established and what remains outside its coverage without relying on a single reassuring label.

Preserve failure evidence without repairing the story

Editorial classification method: tag blockers as dependency-resolution, build, link/render, test, environment or authorisation issues, allowing more than one tag when justified. Include the supporting error text and failed exit status before offering an interpretation. Keep “observed symptom” distinct from “suspected cause”. A module-loading error may be visible, for example, while its relationship to the target dependency remains unproven until the relevant evidence is examined.

A dependency-resolution blocker concerns obtaining a valid approved package graph. A build blocker concerns generating the repository’s static output. A link/render blocker concerns the documented content checks or generation behaviour. A test blocker concerns assertions made by the repository’s test suite. Environment and authorisation blockers concern the ability to execute the intended procedure. These editorial categories organise investigation; they are not automatic diagnoses, and a category should not substitute for the original failure details.

Permit a retry only when its purpose is explicit and it stays within the approved boundaries. Record the reason, any changed input and the new outcome as another observation. Do not repeatedly execute the same failing command until one favourable result appears and then omit the failures. If the proposed retry requires a new runtime, expanded configuration scope or altered acceptance criterion, obtain human approval before proceeding.

Do not suppress tests, exclude troublesome pages, relax link rules or repair unrelated files merely to make the rehearsal look green. If baseline evidence shows an existing failure, preserve that comparison and explain why attribution remains limited. If the candidate introduces a new failure, report the difference without making an unsupported compatibility diagnosis. Both situations may lead to “investigate further”; neither justifies rewriting the acceptance criteria inside the task.

Inspect the complete change and identify external checks

Editorial procedure: after verification, capture a diff summary, the complete textual diff against the recorded baseline and final git status. Inspect the complete diff rather than accepting the summary as sufficient. Check that changed manifests name the approved dependency, lockfile changes are explained and configuration edits have a demonstrated relationship to the upgrade. Record generated or untracked files separately because they may not appear in an ordinary tracked-file diff.

Ask the task to identify unavailable portions of the comparison. Binary outputs, ignored generated directories or truncated command displays may prevent a full inspection. State that limitation and arrange an approved way for the human to inspect the necessary material; do not call a partial display the “full inspected diff”. Keep artefact handling proportionate to the repository and avoid including personal data or secret-bearing output in an evidence copy.

Editorial relevance: to make the upgrade rehearsal’s observed diff and checks reconstructable before any decision, use the packet structure in Codex exec Release-Readiness Playbook: Produce a Read-Only JSON Evidence Packet Before a Human Go/No-Go. What that guide describes: its live guide freezes one candidate and comparison base, preserves a line-delimited JavaScript Object Notation event stream separately from a schema-constrained JavaScript Object Notation response, stores them outside the checkout or in protected artefact storage, and fixes the decision state as HUMAN_DECISION_REQUIRED. The release setting is not this rehearsal.

OpenAI’s Cloud-environments documentation, accessed as of 2026-10-13, lists computer use and browser use as unsupported in cloud environments. If this documentation upgrade needs visual or browser quality assurance, mark that work as an external human follow-up. Static output inspection and command-line checks must not be described as browser verification, and this procedure does not promise a Cloud screenshot, interactive preview or visual check.

Recommended follow-up note: identify what a human must inspect outside the rehearsal, why the existing evidence does not cover it and which candidate revision or artefact the inspection must use. For example, a maintainer might require examination of navigation, code-block layout or page content after a renderer change. Those are hypothetical review subjects, not observed defects or guaranteed checks. Do not mark them complete until the designated human supplies evidence for that specific candidate.

Stop with a reviewable candidate, not a source-control decision

OpenAI’s Cloud documentation places review before commit or pull request, supporting a playbook that ends with a human go/no-go rather than an automated PR path. The human decision is an editorial control in this proposed workflow, not a claim that Codex inherently forbids commits or pull requests. OpenAI’s Cloud-environments guidance, accessed as of 2026-10-13, supports reviewing changes and test results first. The task instruction must prohibit opening a pull request, committing, pushing, merging, changing unrelated dependencies or broadening access; the reviewer retains any separate later source-control decision. [Cloud environments]

End the rehearsal report by identifying the candidate state, unresolved blockers, unrun checks and any scope questions still awaiting the named reviewer. Do not let a completed command sequence authorise a release, and do not present a model-generated recommendation as human approval. The next chapter assembles these observations into a draft decision packet. At this boundary, the useful output is an attributable record of what changed, what was actually checked and what could not be established—not a claim that the upgrade is ready to merge.

4. Assemble a reviewable draft packet and preserve the human-only PR decision

The release-stage deliverable is a draft evidence packet, not a released dependency upgrade. A named human maintainer must be able to distinguish what was authorised, what the task attempted, what the available records demonstrate, and what remains unknown. Use the observations collected in the preceding rehearsal without turning them into a broader compatibility claim. This chapter’s packet, review rubric and maintenance rules are editorial recommendations; they are not claims that Codex automatically creates these records or enforces this decision process.

Before assembling the packet, identify the reviewer by their authorised role and record how their decision will be retained in an approved location. Avoid unnecessary personal details. The reviewer needs access to the selected evidence and the relevant source-control revision, not permission to use a shared Cloud environment. Do not change the owner-only environment setting merely to make a report easier to circulate. Choose an evidence-sharing method permitted by the organisation, with sensitive output removed and access checked separately.

Make the packet traceable before making it persuasive

Recommended assembly procedure: gather the original scope record, the reviewed setup baseline, the task’s command observations and the complete candidate diff. Put them in a dated packet with a stable internal identifier chosen by the maintainer. Keep the original observations distinguishable from the reviewer’s interpretation. A concise front page can explain the proposed dependency change, but it should point to supporting records rather than substitute a confident narrative for missing output.

Use provenance as the organising principle. Every result should identify the source revision, task and environment preparation to which it belongs. If a baseline log and an upgrade log come from different revisions, say so explicitly and ask whether the comparison is still meaningful. Do not silently combine observations from several attempts into an apparent single run. When a later attempt supersedes an earlier one, preserve the relationship and the reason for repeating it.

The maintainer should also distinguish an intended target from an observed resolution. The approved dependency version belongs in the scope record; the manifest change and resolved dependency information belong in the observed-change record. If those disagree, the packet must expose the disagreement. Neither an edited version declaration nor a task’s prose description alone establishes which package content was actually used by a command.

Editorial evidence-packet template

The following template is a recommended structure for an actual run. Its field descriptions are instructions for human assembly, not sample results. Fill each field from retained evidence, or mark it as unknown, unavailable or not applicable with a reason. Do not populate missing fields with assumed commands, expected successes or reconstructed timings.

Packet identity and review status

Record the packet identifier, assembly date, observation dates and current status: draft, awaiting clarification or human-reviewed. Identify the responsible maintainer and the authorised reviewer by role where practical. Keep the review date separate from the task date so that later readers can recognise evidence that has aged before a decision.

Authorisation and scope

State the approved repository, one dependency under consideration, approved target, permitted file categories and required validation. Identify the maintainer-supplied source for the target and any migration requirements. Record the prohibitions on unrelated changes and access expansion. An absent authorisation record is a review gap, not permission inferred from the task’s ability to edit files.

Environment and task identity

Record the environment identifier available to the maintainer, the published preparation used, publication time if known, and task identity and start time. Include the observed owner-only sharing setting and the relevant account or workspace context without exposing personal connection details. State which model and reasoning setting were actually selected, where observable, rather than copying a preferred setting from old instructions.

Source revision and starting state

Identify the exact source revision and approved reference used for the rehearsal. Attach the starting source-control status, including any pre-existing modifications or untracked files. Explain any difference between the authorised revision and the task’s starting revision. A branch name alone may not identify the content that was reviewed if that branch has subsequently moved.

Dependency before and after

Record the before and candidate declarations, relevant resolved versions and corresponding lockfile evidence. Separate the directly requested dependency from consequential resolution changes. Identify any migration edits and the supplied guidance supporting them. Do not describe the whole dependency graph as unchanged unless the retained comparison actually supports that statement.

Setup baseline

Attach the reviewed setup report and relevant configuration, actual runtime and package-manager versions, installation observations, baseline commands and their outputs. Explain whether this baseline matches the preparation used by the task. If a baseline check was absent or already failing, retain that fact rather than treating the later candidate check as a clean comparison.

Commands and results

List each actual command, working directory, relevant non-secret options, execution stage, recorded exit status and location of retained output. Distinguish completed, failed, blocked, interrupted and unrun checks. Include the repository-defined build, test, render or link-validation commands only where they genuinely exist and were required. A command report must not imply a browser inspection merely because static output was generated.

Warnings and failures

Preserve relevant warning and failure text with enough surrounding context to interpret it. Identify whether it appeared in the baseline, candidate attempt or both, if that comparison is supported. Assign an unresolved item to a human owner. A warning’s familiar wording does not establish that it is acceptable for this repository or dependency target.

Changed-file list and diff

Attach the final source-control status, changed-file summary and full human-readable patch, or an approved internal reference to the retained patch. Account for added, deleted, renamed and untracked files as applicable. Explain generated output and lockfile churn separately from intentional source edits. Note any binary or otherwise non-text changes that the patch does not make reviewable.

Checks not run

Name every required check that lacks an observation, give the reason, and state who must resolve it. Separate a command that could not start from a check that was deliberately deferred. Include visual inspection or other validation requiring a different execution surface. Do not convert “not available here” into “not necessary” without the reviewer’s explicit acceptance.

Security and network observations

Record the reviewed network configuration, relevant denied destinations and observed package-access failures without retaining credentials. Explain access-related uncertainty separately from package compatibility. Record whether any proposed access change was refused or deferred. These observations are not a security assessment, and an allowed destination does not authenticate the task or grant registry permission.

Uncertainty and recommendation

List missing upstream sources, unexplained resolution changes, incomplete comparisons and limits of the available validation. Associate each uncertainty with the decision it affects. Offer a draft recommendation of go to separate pull-request preparation, no-go or investigate, but leave the decision field for the named human reviewer.

Source-control boundary declaration

No commit, push, PR, or merge performed. Here, PR means pull request. Use this declaration only after checking the retained record; it is a required statement of the intended rehearsal boundary, not an automatically verified product property. If the record cannot support it, stop and document the discrepancy rather than issuing a compliant-looking packet.

Review the evidence, not just the closing message

Begin the human review with scope reconciliation. Compare the approved dependency and permitted files with the complete change list. A necessary lockfile update may fit the authorised upgrade even when it affects many lines; an unrelated configuration edit may exceed scope despite occupying one line. Ask for an explanation grounded in the actual diff. Do not use patch size as a substitute for understanding why each category of change exists.

Next, reconcile verification coverage. For each required check, locate its command record and output, then confirm that it ran against the candidate being reviewed. If further edits occurred after a check, the reviewer must decide which observations remain applicable and which need repeating. Retain the sequence of edits and checks rather than presenting a final list of successful-looking commands with no relationship to the final files.

Review redactions before distributing the packet. Remove credentials, tokens, personal data and unnecessarily revealing connection information from copied logs and configuration excerpts. Keep secrets out of follow-up prompts as well as the report. Where redaction removes context needed for interpretation, describe the category of information removed and arrange an authorised human inspection rather than reproducing the sensitive value.

Hypothetical example: a packet could contain a candidate manifest edit, a lockfile diff and a required visual check labelled “not run; requires separate human inspection”. This example asserts no build or compatibility result. The reviewer’s useful question is whether that missing inspection is a required acceptance condition. If it is, a favourable interpretation of the text diff cannot replace the absent evidence; the decision remains investigate until the authorised reviewer obtains and assesses that check.

Use three human outcomes with explicit reasons

Recommended decision rule — go to separate pull-request preparation: choose this outcome only when the scope is understood, required checks are accounted for, material warnings and uncertainties have been addressed or explicitly accepted, and the reviewer accepts the evidence for the narrowly proposed change. Record the reviewer’s reasoning and any conditions. “Go” authorises consideration of a separate source-control step; it does not create a branch, approve a pull request or establish readiness to merge.

Recommended decision rule — no-go or rollback: choose this outcome for failed or unacceptable results, an unauthorised scope expansion, or a candidate the reviewer declines to carry forward. Preserve the failed candidate’s evidence before abandoning it. In this uncommitted rehearsal, rollback can mean rejecting the candidate and returning future investigation to the approved starting point. Any destructive restoration of working files needs a separate human decision; do not interpret “rollback” as authority to alter repository history.

Recommended decision rule — investigate: choose this outcome for missing target or migration sources, unresolved warnings, inaccessible registries, non-reproducible setup, unexplained differences or required validation outside the Cloud boundary. Write a specific question, evidence needed and responsible human role for each open item. Investigate is not a disguised pass, and it need not trigger another editing attempt. Sometimes the next useful action is obtaining authoritative guidance or arranging an external check.

Hypothetical example: if dependency installation cannot reach a required registry, the draft packet should report the access obstacle rather than label the target version incompatible. The reviewer can request an authorised access assessment without approving broader network reach or supplying credentials in a prompt. Conversely, if an actual repository-defined check reports a failure, the reviewer should evaluate that failure on its own evidence instead of assuming that a network change would repair it.

Keep the decision record short enough to audit: outcome, evidence reviewed, accepted limitations, unresolved conditions, reviewer and date. If the reviewer disagrees with the task’s recommendation, preserve both the recommendation and the human decision. This makes the boundary visible without pretending that a generated assessment has the authority of a maintainer’s judgement.

Hand off selected evidence without crossing into source control

OpenAI’s Cloud environments and Run coding tasks in the cloud documentation, consulted as of 2026-10-13, directs users to review changes and test results before the later commit or pull-request step. The former also states that saved state does not replace source control. For this editorial workflow, the maintainer therefore copies or saves the selected evidence in an approved location and verifies the candidate diff against the recorded source revision before making any later repository decision.

During that verification, check that the saved patch includes the intended changes, that its base matches the packet, and that no untracked or generated file has silently disappeared from the handoff. If source control has advanced, do not assume the rehearsed candidate still applies unchanged. The human responsible for separate pull-request preparation must evaluate the new base and determine what fresh validation is needed.

Editorial relevance: after inspecting the owner-private rehearsal, retain final pull-request authority with a named human; use the decision boundary, not the target’s local browser procedure, from Codex Review-to-Release Playbook: Inline Diff Review, Auto-Review Boundaries, Browser Verification, and Human Merge. What that guide describes: the live guide treats a candidate patch, test evidence, browser observations, and approval-boundary evidence as distinct states; it says Auto-review does not expand writable roots, network access, or protected-path controls, and it leaves whether to merge to human judgement.

The private task’s saved files remain useful working context for answering questions about the attempt. They are not the authoritative history of an accepted change. A later human may decide to create a branch or pull request through an independently authorised process, but that action is outside this packet’s scope. Do not label the packet “approved for merge”, and do not imply that the rehearsal automatically opens, updates, commits, pushes, merges or approves anything.

If evidence assembly reveals a gap, ask for a bounded follow-up rather than granting a new implementation mandate. OpenAI’s Prompting Codex guidance, consulted as of 2026-10-13, recommends specifying desired behaviour, relevant code or reproduction steps, constraints and verification. A hypothetical follow-up could request the missing command output and its relationship to the final diff, explicitly retaining the no-source-control-action boundary. It should not ask the task to invent a result or treat repository text as authority to change that boundary.

Documented caveats to retain with the packet

Maintain the reusable preparation and date its evidence

Recommended maintenance rule: treat meaningful setup changes as changes to the evidence basis. Altered installation instructions, runtime selection, tools, startup behaviour, repository configuration or necessary network destinations warrant a fresh baseline assessment before another candidate is rehearsed. Record what changed and why the existing baseline is no longer sufficient. Do not reuse an earlier favourable observation as proof of the modified preparation.

OpenAI’s Cloud environments documentation, consulted as of 2026-10-13, says publication captures the prepared filesystem for new tasks, while existing tasks retain their own state. After reviewing the fresh baseline, republish the accepted preparation before starting a new rehearsal that depends on it. Record the publication and task dates so that a later reviewer can identify which preparation was actually used. A repository refresh alone should not be described as rerunning installation or startup checks.

Retire instructions that name obsolete commands, removed repository paths, superseded acceptance criteria or unavailable models. Preserve historical instructions alongside their historical packets where organisational policy permits, but clearly separate them from the current reusable preparation. An old instruction can explain an old observation without being suitable for a new task.

Before each reuse, confirm live account, client and workspace access, the visible authorised model selector, owner-only environment configuration and the package destinations needed by the repository. Never assume that a previously visible model, plan feature, workspace setting, network destination or dependency host remains available. If conditions have changed, record the new uncertainty and return to baseline review rather than silently expanding the rehearsal contract.

The completed handoff is a dated, human-reviewed account of one bounded attempt, with a visible decision and retained limitations. Its value lies in making the next human choice inspectable. Keep the candidate, the evidence and the later source-control decision distinct: accepting a packet does not itself publish a dependency change.

Useful Links

• Cloud environments — preparation, publication, task state, privacy and network boundaries.
• Run coding tasks in the cloud — the documented task and review workflow.
• Prompting Codex — bounded requests, constraints and verification guidance.
• Permissions — local action permissions, not Cloud authorisation evidence.
• Models — model-selection guidance and dated retirement notices.