Codex Local Multi-Folder Projects vs Remote Host Handoff: A Documentation-Led Comparison for Split Repositories

Start with the repository boundary, not the machine

For a split-repository task, the first decision is not simply whether Codex should run locally or remotely. It is which repository, directory and environment the work should belong to. Related folders can be close together on disk without belonging to the same Git checkout. Conversely, one repository can contain several projects whose dependencies and review responsibilities differ. A useful comparison therefore separates the material Codex needs to understand from the checkout it is allowed to change and the host that supplies its tools.

This article uses OpenAI’s Codex documentation as available on 9 October 2026: Local environments, execution modes, Git worktrees and remote connections. These are documentation-led distinctions, not findings from a hands-on comparison. The sources establish configuration locations, execution choices and handoff boundaries; they do not supply comparative speed, quality, reliability or cost measurements.

The practical choice is between retaining a task in a selected local project, with any related-folder context explicitly checked, and moving a chat plus Git state to a connected host with a matching repository project. Neither arrangement should be treated as a way to package and move a complete developer workstation. Keeping that distinction visible makes it easier to decide where a task belongs before asking Codex to edit files.

Three terms that must stay separate

Selected project directory means the directory used as the project for the task. It matters because the local-environment documentation places configuration in the project’s .codex folder. In a repository containing several projects, the documented guidance points to the directory containing the shared configuration. That gives an engineer a starting point for selecting the project; it does not establish that every neighbouring directory is readable, relevant or already included in the model’s context.

Current checkout means the Git working copy whose files and Git state are being operated on. It is not interchangeable with the collection of folders mentioned in a conversation. A task might require reading an interface definition from a second project while making changes only in the first. Understanding the second project does not, by itself, authorise changes to its checkout. The documentation’s built-in Git controls concern the current checkout, rather than an arbitrary collection of repositories named in a prompt.

Connected host means the destination environment that supplies the remote session’s resources. According to OpenAI’s remote-connections documentation, as of 9 October 2026, remote access uses that host’s projects, chats, files, credentials, permissions, plugins, Computer Use, browser setup and local tools. This is a resource boundary, not merely a different screen through which the original laptop is controlled. Local documents and services should not be presumed present at the destination because they were useful in the source conversation.

These terms answer different questions. “Which directory did we select?” establishes the project boundary. “Which checkout owns the proposed edits?” establishes the change boundary. “Which host supplies the required resources?” establishes the environment boundary. A sound task description answers all three, even when the answers happen to point to one directory on one computer.

What a local multi-folder arrangement establishes

A Codex project can contain more than one project, and the local environment configuration belongs in the project directory containing the shared .codex folder. OpenAI’s Local environments documentation, as of 9 October 2026, supports this configuration arrangement; it does not promise automatic model context or universal access to every sibling folder. [Local environments]

The important distinction is between configuration placement and usable task context. A shared .codex directory identifies where the documented local-environment configuration belongs. It is not evidence that a file outside the selected project has been read, that a sibling repository is under the same Git controls, or that permissions extend across a parent directory. The official pages do not precisely define a universal context boundary for arbitrary secondary folders. Treat that as something to inspect in the actual project, rather than an implicit capability.

For a hypothetical repository containing a website and a worker service, selecting their common project root may be a sensible starting arrangement. The task could require comparing a request type used by the website with the worker’s corresponding parser. Before relying on that comparison, the engineer should establish the exact paths involved and whether those files can be inspected from the selected project. If a required file is unavailable, the task’s evidence is incomplete; the answer is not to assume that the shared configuration made it visible.

Even when both files can be read, their roles can differ. One might be authoritative evidence of the interface, while the other is the intended edit target. A third file could be generated output that should not be edited directly. Those distinctions belong in the task brief. They help prevent a request to “make these projects agree” from becoming an open-ended invitation to change everything that appears related.

When several repositories must be reasoned about together, the decision is about which folders share project context, not about permission to change every repository. The multi-repository desktop project playbook describes a desktop workflow that aggregates repositories to map dependencies, enforce standards and coordinate changes, offering a different way of organising context from this article’s choice between a local project and a remote host.

For this comparison, “multi-folder” is therefore a description of the engineer’s project arrangement, not a claim about unrestricted access. It can describe multiple projects inside one repository or related directories whose Git ownership must be established separately. The more useful question is whether the required evidence and permitted edits can be bounded within the selected local arrangement. Physical proximity on disk is not a substitute for that boundary.

Reading related code is not ownership of its Git state

A hypothetical task might say: “Use the worker’s schema to understand the website change, but edit only the website.” That is a reasonable division of evidence and authority. It still needs a named checkout and a reviewer who understands which project owns the interface. If the worker lives in a different Git repository, its branch and changes cannot be treated as part of the website’s current checkout merely because both folders appear under a common parent.

The practical implication is to state both a reading scope and an editing scope. A broad reading scope may be useful for tracing a contract across projects. A narrow editing scope may be necessary because a different team owns the other project, because its changes are already under review, or because the task only concerns one implementation. These are hypothetical engineering reasons for a boundary, not Codex-enforced guarantees. A human must inspect the resulting diff against the intended scope.

A shared configuration also cannot resolve an ambiguous source of truth. If two related projects disagree about a field name, Codex needs an identified authority or a request to report the discrepancy. Asking it to choose whichever implementation looks more plausible would turn a context-gathering task into an unapproved interface decision. For consequential changes, the responsible engineer must decide which contract governs before implementation proceeds.

Execution mode and host location are different decisions

Local, Worktree and Cloud are distinct execution choices: Local and Worktree both run on the computer, and Worktree additionally isolates changes in a separate Git worktree. OpenAI’s execution-modes documentation, as of 9 October 2026, makes this distinction; the comparison here concerns local project context versus a connected host, not delegation to Cloud. [Codex environments]

This distinction prevents two common category errors. First, choosing an isolated worktree does not mean that the task has moved to a different computer. Second, handing work to a connected remote host is not the same as selecting Cloud. The vocabulary matters because each option changes a different part of the task: where changes are isolated, where commands execute, or which environment supplies the files and resources.

OpenAI’s Git worktree documentation, as of 9 October 2026, describes worktrees as Git-backed checkouts with separate file copies and shared Git metadata. That is enough to understand their role in this foundation: they separate working copies within a repository arrangement. Their detailed creation, branch ownership and local handoff mechanics are separate questions. They should not be used to infer support for arbitrary cross-repository changes or the transfer of an entire environment.

Likewise, the local-environment page documents setup steps for worktrees and common project actions, with configuration that can be checked into the repository. Those features help describe a repeatable project setup. They do not prove that another host already has the required dependencies, authorised credentials or running services. Configuration is an input to environment preparation, not evidence that two environments are equivalent.

Before choosing a local project arrangement, engineers should define which repository is the primary editing target and which folders are reference-only; the local project hardening guide details narrow primary-folder access, read-only secondary folders, project-trust review, layered configuration, sandboxing, approvals and filtering of credential-bearing files or shell variables.

A useful decision sequence is to establish the project and evidence boundary first, then decide where execution belongs, and only then choose how changes should be isolated. Starting with “remote” or “worktree” can obscure an unresolved repository mismatch. Starting with the exact project allows the later choices to be evaluated against a concrete task rather than a general preference for one mode.

A hypothetical map for a split-repository task

Consider the following hypothetical workspace. Its names are inert local names, and nothing in this example represents a tested Codex session. The purpose is to make the decision boundaries visible before any implementation is requested.

• workspace/harbour/ is one Git repository, containing web/, worker/ and a shared .codex/ directory.
• workspace/contracts/ is a separate Git repository containing interface definitions used by both projects.
• workspace/review-notes/ contains local working documents, outside either repository.
• A separately approved connected host has a saved project for harbour/worker and its own provisioned worker environment.

This map contains three different forms of relationship. The website and worker share a repository and a configuration location. The contracts directory is related by dependency but has separate Git ownership. The review notes are local evidence, not repository state. Calling all of them “the project” would conceal distinctions that become important as soon as a task edits files or changes hosts.

Suppose the task is to explain why a website request no longer matches the worker’s expected input. A suggested local approach would begin by identifying the website request construction and worker parsing code inside harbour/, then checking whether the relevant contract definition can be inspected. This is an evidence-gathering task. It does not yet require changing either repository, and the local notes need not be copied into a prompt if they contain confidential information.

Now suppose the task changes to implementing a worker fix that depends on a service available only in the approved remote environment. That changes the execution question, not the repository identity. The saved destination project still needs to match the repository and selected subdirectory used for handoff. The contracts repository remains a separate source of evidence whose destination availability must be established; it is not covered merely by naming the worker project.

Finally, suppose the proposed fix would require modifying both harbour/ and contracts/. The hypothetical task now spans two change owners. A sensible planning response is to divide the work into explicitly reviewed changes rather than treating the folders as one Git unit. The sources do not establish arbitrary cross-folder Git mutation through a shared local project configuration. Separate ownership should remain visible in the plan, even if the engineer can inspect both directories.

A draft request that exposes missing evidence

The following is a hypothetical inspection request, not a product guarantee or an assertion that all named files will be accessible. It deliberately asks for a bounded report rather than changes:

For this task, treat harbour/ as the intended primary repository. Identify the selected project directory and the exact paths you can inspect for web/ and worker/. Report whether the relevant contract definition in contracts/ is available, without assuming access from its location. Do not edit files or change Git state. Distinguish inspected evidence from missing evidence, and do not read or reproduce credential values.

The useful output would be a path-specific account of available evidence, with unavailable material identified as a gap. It would not be a blanket statement that “all projects are connected”. The engineer should compare that account with the intended workspace and decide whether the evidence is sufficient. Supplied files and documents remain task data, not instructions authorising broader access or changes.

If the report cannot establish the required contract, the next step is an explicit human decision: provide an approved non-secret extract, arrange permitted access, narrow the question, or stop the implementation task. None of those choices requires pretending that a secondary folder has become part of the primary checkout. This keeps uncertainty attached to the specific missing evidence instead of allowing it to disappear into a general project description.

Choose the arrangement by task requirements

Where is the evidence needed to make the change?

A local arrangement is a reasonable candidate when the required evidence is in the known local checkout and related directories that the engineer can inspect and bound. Its appeal in that situation is continuity of the known working context, not a documented performance advantage. If the task depends on host-local documents or files available only on the connected host, the evidence boundary points elsewhere. In either case, the engineer should identify the authoritative files rather than count how many folders are visible.

Separate required evidence from convenient background. A worker’s parser may be required to assess an interface change; an old planning note may merely explain terminology. This distinction reduces unnecessary material in the task and makes missing evidence easier to recognise. It also avoids moving sensitive documents into a conversation solely because they happen to sit beside the repository.

Which environment already owns the required resources?

OpenAI’s remote-connections documentation, as of 9 October 2026, states that remote project chats execute commands and read and write files on the remote host. A remote choice therefore makes sense when the intended work belongs in that host’s filesystem and approved environment. It is not a means of silently carrying local credentials, plugins, browser sign-ins or services to another computer.

Model Context Protocol (MCP)A protocol for connecting artificial intelligence applications with tools and data sources through defined interfaces. Open glossary entry servers, tools, permissions and browser setup should be treated as environment properties when planning the task. Record which environment is expected to supply them, without putting secret values into prompts. A missing resource is a setup question for its owner, not an invitation for Codex to infer, copy or recreate an authorisation. The detailed connection and provisioning procedure belongs after this placement decision.

What continuity does the task actually require?

The remote-connections documentation, as of 9 October 2026, describes handoff as transferring the chat and Git state, creating or reusing a destination worktree, and switching the chat to that host. It requires a saved destination project for the same repository and the same subdirectory when applicable. That is the documented continuity boundary. It should not be expanded into a promise about arbitrary local folders, ignored files, running processes or credential migration.

If a task depends on a local service continuing uninterrupted, that dependency must remain explicit. If it depends only on the recorded discussion and repository changes, the documented handoff may fit its continuity needs, subject to destination checks. The official sources do not enumerate every Git metadata field or every file category transferred remotely, so unresolved state should be recorded as a verification requirement rather than described as guaranteed continuity.

Who can validate the destination and the change?

Review responsibility is part of placement, not a final administrative step. Before choosing an arrangement, identify the human who can confirm the intended repository, understand the affected interface and authorise consequential changes. A destination that has the right tools but no available reviewer may be unsuitable for the proposed scope. Similarly, a local project with readable related code may still lack authority to change the other project.

The eventual handoff plan must inventory repository identity, saved project and subdirectory match, branch and worktree state, staged, unstaged, untracked and ignored files, required setup, running processes, and the presence and ownership of credentials without recording their values. After transfer, a human must verify the destination, branch, changed files, diff, tests and required approvals. Those checks are the operational follow-through to this article’s decision, not evidence that transfer has already preserved every dependency.

The foundation is therefore a bounded task description: which evidence is required, which checkout may change, which host supplies the environment and who approves the result. Keeping related folders local is useful only when those boundaries are understood. Connected-host handoff is useful only when the matching project and host-local resources satisfy them. Neither choice removes the need to resolve missing context or to review consequential changes.

Prepare the local project for controlled work

The local procedure starts by establishing a checkout that a human can identify and review, rather than by requesting an edit. As of 9 October 2026, OpenAI’s undated Local environments, Modes and Git worktrees documentation describes project-level configuration, work in the current project directory, and Git-backed isolation. Those are the documented mechanics used here. The steps below are suggested inspection and review methods, not a claim that a particular repository has been tested or that every folder will be accessible.

Keep two records separate throughout this procedure: the directories needed to understand the task, and the checkout authorised to receive changes. In a hypothetical workspace, a web application might need an interface definition from a worker directory. Reading that definition does not make the worker’s repository part of the web application’s Git operation. This distinction becomes especially important when a directory tree contains nested repositories or adjacent checkouts with similar names.

The aim is to produce a small, inspectable source-state record before choosing whether to continue locally, create a local worktree, or prepare for a later remote handoff. It should identify the selected project, the relevant files, the Git state and the setup requirements without copying sensitive material into the conversation. A human should resolve ambiguity before allowing consequential changes, not merely ask Codex to proceed cautiously.

Confirm the selected root and inspect readable context

OpenAI’s Local environments documentation, as of 9 October 2026, says that a repository containing more than one project should be opened at the project directory containing the shared .codex folder. It also places the local environment configuration in .codex at the project root. Apply that instruction to the actual directory structure; do not choose a parent directory simply because it happens to contain several unrelated repositories.

For a hypothetical repository called harbour-repo, suppose web/, worker/ and .codex/ are all directly beneath the repository root. The engineer can begin by recording that root and asking for a read-only inspection of the relevant paths. This is a suggested method for checking context, not a guarantee that Codex automatically includes both application directories in its working context.

Hypothetical draft request: “Before editing, report the current project directory and the Git repository root. Inspect the directory names under web/ and worker/, then identify the files needed to understand the worker interface used by the web application. Report any unreadable or missing paths. Do not change files or print credentials.”

Review the reported paths against your own checkout. A plausible file name is insufficient evidence: confirm whether it belongs to the intended repository, whether it is a generated copy, and whether it is the version the application actually uses. If Codex cannot inspect a relevant directory, record that as missing context. Do not turn the absence into an assumption that another folder with a similar name is equivalent.

Then narrow the editing boundary. In this hypothetical task, the worker code can be read for interface context while only files under web/ are eligible for modification. Name any specific exclusions, such as a generated client directory or a dependency lockfile that the task does not require changing. These are human-defined task constraints; the configuration location alone does not establish them.

If the inspection reveals separate Git repositories, create a separate identity record for each one. Record which repository supplies context and which owns the proposed patch. The assigned documentation describes Git-backed worktrees and operations on the current checkout; it does not establish arbitrary cross-folder Git mutation. A change spanning two repositories therefore needs an explicit human plan for both repositories, rather than an assumption that selecting their common parent creates one reviewable change.

Make local setup and actions reviewable

Local environments provide setup scripts for new worktrees and actions for common tasks; the configuration can be checked into the repository. OpenAI’s Local environments documentation, as of 9 October 2026, limits this feature to Codex in the ChatGPT desktop app; a checked-in setup definition is not evidence that another host has the same dependencies, credentials or running processes. [Local environments]

Treat the configuration as an executable part of the project’s working procedure, not as harmless descriptive text. Before using it, have a human inspect the setup steps and common actions. Identify which steps install dependencies, which generate files, which require network access, and which expect a service or credential to exist already. Do not place secret values in a script or in a prompt to make a missing prerequisite disappear.

The same documentation states that setup scripts run automatically when Codex creates a new worktree at the start of a new chat. That makes timing relevant: review the setup before starting the worktree, rather than discovering its effects afterwards. If a setup step might overwrite generated files or contact a consequential service, resolve its intended scope and required approval first. The existence of an automatic setup mechanism is not an assurance that every repository’s script is safe or sufficient.

In the hypothetical harbour-repo arrangement, a useful review would distinguish a dependency-installation step from a web test action and from a worker service prerequisite. The installation step might prepare the checkout, while the test action might exercise only the web application. Neither should be described as validating the worker integration unless the actual command and required environment support that conclusion. This example proposes a review structure; it does not supply a tested configuration.

Record the working directory expected by each action. A command intended for web/ should not be silently interpreted as a repository-wide check, and an action operating at the root should be examined for its effects on other folders. Record required dependencies from the project’s actual files and documentation, including relevant lockfiles. Do not invent a universal command sequence for a repository whose package manager and test framework have not been inspected.

Checking the configuration into Git can make the setup definition available for review alongside the code. It does not reproduce everything on the machine. Keep a separate prerequisite list for installed tools, local services, browser sign-ins, environment-variable names and credential ownership. Where MCP servers or plugins are required, record their role and approval requirements without exposing connection secrets. These remain environment properties, not contents implicitly carried by a configuration file.

Establish Git state before creating isolation

OpenAI’s Modes documentation, as of 9 October 2026, distinguishes Local work in the current project directory from Worktree isolation in a Git worktree; both run on the computer. Use that distinction operationally. Continuing in Local means reviewing the existing checkout as the place where changes will occur. Choosing Worktree means first deciding which Git starting point and local changes belong in a separate checkout.

Record repository identity and change categories

Begin with repository identity, not just branch name. A useful human-maintained record contains the exact repository root, selected project or subdirectory, current commit, branch or detached state, and worktree path. Include the source machine’s identity so that later notes cannot confuse two checkouts at the same path on different computers. Repository remote information can help distinguish repositories, but inspect it privately and redact any embedded credentials before sharing metadata.

The following commands are a hypothetical read-only inspection sequence for an engineer’s terminal, not required Codex interface steps. They help gather evidence for the record; their outputs must be interpreted in the repository being inspected.

git rev-parse --show-toplevel
git rev-parse HEAD
git status --short --branch
git worktree list
git diff --stat
git diff --cached --stat
git ls-files --others --exclude-standard
git ls-files --others --ignored --exclude-standard

Separate staged changes from unstaged changes. Review their file names and then their relevant diffs privately, because a summary of changed paths does not reveal what the patch contains. Also inspect whether a merge, rebase or cherry-pick is already in progress. If it is, have the human responsible for that operation decide how to proceed before introducing another task or moving the chat.

Untracked and ignored files need their own inventory. A new source file can be untracked even when it is essential to the requested change; an ignored file can be necessary to run the application without belonging in the patch. Merely noting that the checkout is “dirty” loses this distinction. Record each relevant file’s category and intended treatment: include in the proposed change, leave untouched, regenerate, or provision separately.

Inspect file names and contents locally before copying any inventory into chat. An ignored .env.local, for example, should be recorded by its presence and purpose, not by its secret values. Also avoid reproducing sensitive paths unnecessarily. A short note such as “local service credential present; owned by the development account; not included in the patch” can preserve the operational fact without disclosing the credential.

Use the inventory to separate the user’s existing work from the new task. In a hypothetical checkout, an already-staged documentation correction and an unstaged worker experiment may coexist with the requested web fix. Agree which changes belong to the task before creating isolation. This is a review decision: do not assume that all local changes should be incorporated merely because the worktree creation flow can apply uncommitted changes.

Choose the worktree starting state deliberately

Worktrees are Git-backed parallel checkouts with separate file copies and shared Git metadata, and Codex can start them from a selected branch or the current branch, including its local changes. OpenAI’s Git worktrees documentation, as of 9 October 2026, requires the project to be part of a Git repository and describes the default Codex-managed worktree as detached HEAD (a checkout pointing directly to a commit rather than a branch), so verify the resulting state rather than assuming a named feature branch is checked out. [Worktrees]

The starting-point decision should be written in terms a reviewer can check. State the intended branch or commit, whether existing uncommitted changes are part of the task, and which worktree will own further edits. The documentation says that when a selected branch has local changes, Codex applies those uncommitted changes to the worktree as well. Inspect the resulting changed-file list; do not treat the choice of branch as proof that only committed content was used.

Separate file copies provide a different editing location, while shared Git metadata means the worktrees are not unrelated repositories. Review branch ownership before assuming two sessions can independently occupy the same branch. OpenAI’s Git worktrees documentation states that Git allows a branch to be checked out in only one place at a time. A human should therefore know which checkout owns the branch and which checkout is detached before directing branch-related operations.

A detached HEAD needs an explicit label in the record. Do not write “feature branch ready” merely because the worktree was started from a feature branch: the starting branch and the current checkout state are different facts. Record the current commit and detached status, then decide how the proposed work will be preserved and reviewed before consequential Git actions. Branch naming and integration remain human-owned decisions, not conclusions inferred from the chat’s task description.

For the hypothetical web fix, the source record might say: “Start from the reviewed integration commit; include only the existing web changes that the reviewer has accepted as task input; inspect the new worktree before editing.” This is a sample plan, not a claim about a resulting checkout. If the inspection shows unrelated files, pause and resolve their ownership rather than proceeding on the theory that isolation has already made them harmless.

A handoff decision should record the exact checkout rather than treating a project label as sufficient; the Git worktree verification guide uses isolated worktrees for bounded parallel fixes and emphasises a known base branch and commit, branch occupancy, environment setup, diffs, handoff and independent human review.

Handle ignored files without assuming transfer

OpenAI’s Git worktrees documentation, as of 9 October 2026, describes Local-to-Worktree handoff as moving the chat and code through Git operations. It also states that files covered by .gitignore do not move with the chat unless Codex copies them into a local managed worktree using .worktreeinclude. Keep that documented local behaviour separate from any later remote-host handoff.

Before relying on an ignored file, establish what it does. An ignored build directory might be reproducible from checked-in inputs; an ignored local configuration might need deliberate recreation; a credential file should remain subject to the organisation’s approved provisioning method. These are hypothetical categories for review, not automatic rules for a particular repository. Decide treatment from the actual content and ownership, not from the fact that Git ignores it.

If .worktreeinclude is relevant, review the actual inclusion configuration and the files it would encompass before using it. Do not broaden inclusion merely to make a command succeed. In particular, the documented copying mechanism is not an instruction to copy secrets, and it does not establish a remote transfer rule. Keep the smallest necessary set of local worktree inputs and verify that excluded files are genuinely unnecessary or separately supplied.

Untracked files should remain visible in the checklist even though they are not the same category as ignored files. The assigned sources do not enumerate a universal transfer rule for every untracked or ignored file during remote handoff. For an essential untracked source file, the human must decide how it becomes part of the reviewed work and then verify its presence in the relevant checkout. For an incidental scratch file, the human may instead exclude it from the task.

Review local work and prepare the source record

Inspect the worktree before running actions

Once the local worktree exists, repeat the identity and status inspection there. Check the path, repository root, current commit, branch or detached state, and changed-file categories. Compare them with the intended starting record. This is a suggested human checkpoint, not a claim that creating a worktree certifies those facts. If setup has run, inspect any files it changed as well as the application files.

Only then authorise the bounded edit. A concise hypothetical draft request would be: “Use the inspected worker interface as read-only context. Limit changes to the approved web files. Before running an action, state its working directory and prerequisites. Report unexpected changes and stop for review rather than modifying worker files or local configuration.” This request sets expectations without suggesting that prompt wording replaces file and diff review.

Choose checks from the repository’s actual setup and task requirements. Record what command ran, where it ran, and which prerequisites were present. A web-only check should remain labelled web-only; a missing worker service should remain a missing prerequisite. If execution is not authorised or the environment is incomplete, report that limitation rather than presenting an unrun check as evidence of correctness. No performance or reliability comparison follows from this procedure.

Have a human inspect the final diff, including generated files and configuration changes. Compare it with the authorised file boundary and the initial inventory of pre-existing work. Review whether any sensitive content entered changed files or output. The human owns the decision to commit, push, integrate or approve the change; a completed assistant response is not approval for those actions.

Assemble the source-side handoff inventory

If the work may continue on another host, preserve the source-side evidence while it is still easy to inspect. Record the repository identity, selected project and any subdirectory, commit, branch or detached state, and worktree location. Keep staged, unstaged, untracked and ignored files distinct. Record active Git operations and the changed-file list so a later reviewer can compare the destination with a known source rather than with recollection.

Add an environment inventory without exporting the environment itself. Note required setup scripts and actions, dependency files, installed tools, local services, relevant ports, browser sign-ins, MCP servers and plugins. For credentials and environment variables, record required presence, scope and owner, never values. Running processes should be identified as source-side prerequisites; do not describe them as state that will migrate with the chat.

OpenAI’s Remote connections documentation, as of 9 October 2026, requires a saved destination project for the same Git repository and, where applicable, the same subdirectory. Use that requirement to make the source record precise enough for a later match. “Worker project” is not sufficient if the actual selected project is harbour-repo/worker. Destination connection and provisioning are separate checks; this local procedure supplies the evidence they need.

Remote execution should be assessed as an environment with its own host-bound workload and review path, not as a promise that local tools or sign-ins move with the conversation; the remote host mobile workflow examines a mobile control and review surface paired with a Mac or Windows host, where the host performs the work while the phone directs and reviews it.

Finish the record with the approved edit scope, required checks and named human reviewer. It should also state which local inputs are excluded or require separate provisioning. After any handoff, a human must verify the destination, branch or detached state, changed files, diff, test environment and approvals before consequential action. That later verification cannot be replaced by a clean source checkout or a successful local setup step: each establishes only the facts actually inspected.

Control the connected-host boundary

A remote handoff is a change of execution environment, not merely a different view of the same local project. The practical control question is therefore whether the destination is prepared to own the next stage of work. Repository matching matters, but so do the account running commands, the files available outside the repository, the installed tools and the policies governing their use. A chat that contains a useful explanation of the task does not itself establish any of those conditions.

As of 9 October 2026, OpenAI’s undated Codex remote-connections documentation describes a bounded operation: connect the destination host, save a matching project there, then transfer the chat and Git state into a destination worktree. It does not describe migration of a complete workstation. This article treats that distinction as an operational boundary: prepare the host independently, identify what the handoff is documented to carry, and reserve consequential decisions for a human who can inspect the destination.

The controls below are suggested preparation methods, not additional Codex guarantees. They are intended to make missing prerequisites visible before a remote session is allowed to change files or use sensitive resources. They do not establish that two environments are equivalent, and they cannot replace inspection of the actual host.

Match the saved destination project, not just its name

OpenAI’s remote-connections documentation, as of 9 October 2026, requires the destination host to be connected and to have a saved project for the same Git repository before handoff. Where the project is a repository subdirectory, the same subdirectory must be saved on both hosts. These are distinct requirements. A host can be reachable while its saved project points at an unrelated checkout; a repository can be correct while the selected project directory is wrong.

Use repository identity and the relative project path together when preparing the destination. Matching folder names are insufficient evidence. Two directories called worker could belong to different repositories, while two differently named checkout roots could contain the same repository. A suggested private preparation record should therefore identify the repository, the selected subdirectory relative to its root, and the destination’s actual checkout path. Review repository metadata privately if it contains sensitive host or account information.

In a hypothetical arrangement, the source project is harbour-repo/worker, while a connected host stores the repository under build-area/harbour-repo. The relevant project match is the worker subdirectory within the same repository, not identical absolute paths on both machines. Saving only the destination repository root would not satisfy the documented same-subdirectory prerequisite for that source project. The engineer should resolve that mismatch before requesting handoff, rather than expecting the conversation to correct the destination selection.

This matters particularly when related code is divided across repositories. A saved project for the worker repository does not establish a destination checkout for a separate interface repository discussed in the chat. Treat that second repository as a separate preparation item. If the task depends on reading it, a human should establish whether the required files exist and are accessible on the destination. If the task depends on editing it, define that authority separately; do not infer arbitrary cross-folder Git operations from a successful match for the primary repository.

A useful destination preparation note records facts rather than intentions: which repository is present, which subdirectory is saved, which account will operate there, and which additional directories the proposed task needs. “The host should have the worker project” leaves an unresolved prerequisite. “A human has inspected the saved worker project and its repository identity” records a check, but should only be written after that check has actually occurred.

Establish the access route and its prerequisites

Different connected-host routes need different preparation. Do not combine a connected computer’s desktop-app conditions with Secure Shell (SSH)A protocol for secure remote login and other secure network services over an insecure network. Open glossary entry requirements into one assumed setup. As of 9 October 2026, OpenAI’s remote-connections documentation describes remote access stopping when the connected computer sleeps, loses network access or closes the app. It also describes SSH project chats as running commands, reading files and writing changes on the remote host. In either case, the destination must actually remain available for the intended work.

For the documented SSH route, Codex reads concrete host aliases from ~/.ssh/config, resolves them with OpenSSH and ignores pattern-only hosts. A suggested preparation sequence is to identify the concrete alias privately, establish that ordinary SSH access works for the intended account, and check the shell environment that will be used remotely. A broad configuration pattern is not a substitute for the discoverable alias described in the documentation. Do not paste private keys or credential-bearing configuration into the chat to demonstrate connectivity.

The remote-connections documentation also requires the codex command to be available on the remote host’s PATH in that shell. This is a destination prerequisite, not something established by having Codex installed locally. Check it alongside the tools needed for the proposed task. A remote shell that can launch Codex may still lack the project’s compiler, package manager, test dependencies or approved access to a required service. Record these as separate readiness questions rather than one undifferentiated “host works” check.

OpenAI’s documented security expectations for SSH hosts, as of 9 October 2026, are trusted keys, least-privilege accounts and no unauthenticated public listeners. For access beyond the current network, the documentation recommends a virtual private network (VPN)A protected logical connection that carries traffic across another network. Open glossary entry or mesh networking tool rather than exposing the app server directly to the internet. Apply those expectations through the organisation’s approved host configuration. They are not a basis for claiming that an arbitrary remote connection is secure.

Where a connected-computer flow depends on rollout or workspace settings, confirm enablement before planning a handoff around it. An engineer’s expectation that a feature exists is not evidence that the relevant workspace permits it. Likewise, documented prerequisites do not amount to an uptime guarantee. The preparation question is whether the selected route is enabled, authorised and reachable now, with an owner who can maintain the host’s availability.

Keep resources attached to the host that supplies them

A connected host supplies the remote session’s projects, chats, files, credentials, permissions, plugins, Computer Use, browser setup and local tools. These are destination-host resources; the documentation does not say that equivalent resources are copied from the source machine during handoff. [Remote connections]

That statement, from OpenAI’s remote-connections documentation as of 9 October 2026, changes how to write the task’s prerequisites. Instead of asking whether the source chat previously used a tool, ask whether the destination has the required tool and whether its use is approved there. Instead of assuming that a file mentioned earlier remains readable, identify its destination location. Conversation continuity can preserve discussion of a resource without proving that the resource exists on the new host.

Credentials need an especially strict separation between description and disclosure. A suggested readiness record can state that a required credential has been provisioned for an approved account, who owns it, what scope it is intended to cover and whether its validity has been checked. It should not contain the credential value. Keep secret values out of prompts, draft requests, pasted terminal output and review notes. If verification requires inspecting a secret-bearing file, the human should do so privately rather than asking the assistant to reproduce its contents.

Browser setup should be treated similarly. A source machine’s authenticated browser session is not evidence that the destination browser has the required sign-in. If a task needs browser access, identify which destination account and setup are approved before allowing that step. Do not ask Codex to “continue using my login” on the strength of the source conversation. The documentation’s host-local resource model requires a new check of the destination’s actual browser state and permissions.

For plugins, MCP servers and other tools, record the capabilities required by the task without assuming that the same integrations are present on both machines. A hypothetical worker task might need a repository search tool and access to an approved test service. The destination preparation record should distinguish those two dependencies: repository search availability does not establish permission to contact the service. This distinction also helps the reviewer understand whether a missing capability prevents inspection, execution or both.

Local documents deserve their own entry when they influence the change. In a hypothetical case, an engineer has an architectural note outside harbour-repo on the laptop. Mentioning that note in the conversation does not establish a copy on the destination. The engineer can decide whether approved, non-sensitive information from it should be included in the task brief, or whether an authorised destination copy is needed. Neither choice should be described as automatic document migration.

Permissions and policy remain destination properties too. A source account’s ability to run a command does not grant the remote account the same authority. Before consequential actions, a human should approve the intended use of destination services and data under the applicable host and workspace controls. This is a review requirement, not a claim that handoff itself validates permission.

Bound the transfer to what the documentation describes

Handoff between local and worktree moves the chat and code, and Codex performs Git operations needed to move safely; the same branch cannot be checked out in both places at once. This describes Local-to-Worktree behaviour, not a promise that arbitrary local directories, ignored files or host resources are transferred to a remote destination. [Worktrees]

OpenAI’s Git-worktrees documentation provides that Local-to-Worktree account as of 9 October 2026. Its remote-connections documentation separately says that remote handoff creates or reuses a worktree on the destination host, transfers the chat and Git state, and switches the chat to that host. Keep those descriptions separate when reasoning about a split repository. The local mechanism explains a Git-backed handoff boundary; it does not extend the remote transfer to everything that happened to be accessible on the source machine.

The phrase “Git state” is useful but should not be expanded into an invented list of guaranteed metadata fields. The assigned documentation does not enumerate every Git metadata detail that survives remote handoff. Use the source record to establish the branch or detached state, commit, worktree and change categories that matter to the task, then have a human check the destination against those expectations. That inspection is necessary precisely because the broad transfer description is not an exhaustive field-by-field contract.

Ignored files are a concrete example of this limit. As of 9 October 2026, OpenAI’s Git-worktrees documentation describes .worktreeinclude behaviour for copying matching ignored files into local managed worktrees. That is not a documented universal rule for remote-host handoff. If an ignored file is essential to execution, establish how the destination obtains an approved equivalent independently. Do not use the local inclusion mechanism as evidence that it will accompany the chat to another host.

In a hypothetical source checkout containing an ignored .env.local, the preparation note could record only that the file exists and that the task requires a separately provisioned destination configuration. The engineer should not copy its contents into the chat to compensate for uncertain transfer. If the file contains secrets, the credential owner should arrange destination access through the approved process, and the human reviewer should verify presence and scope without exposing values.

Untracked files also need explicit attention without an invented transfer guarantee. Some may be proposed source files; others may be temporary artefacts or private notes. Classify their relevance before handoff and identify any file on which the task depends. The remote-transfer documentation does not provide a universal rule for every untracked or ignored file, so the safe preparation method is to record what is required and inspect what is actually present after transfer.

Because the documented handoff boundary is limited to chat and Git state, any additional file, log, credential or destination must be considered separately; the artifact transfer authorization playbook treats artifacts and handoff notes as controlled objects and calls for explicit identity, task, namespace, credential scope, destination, retention and human approval before a transfer.

Separate task interruption from process migration

As of 9 October 2026, OpenAI’s remote-connections documentation says that handing off while a task is running interrupts the current response before transfer. This is a statement about the handoff’s handling of that response. It does not promise migration of a development server, watcher, database connection, browser session or other running process. Do not turn “continue the chat there” into “continue every process there”.

Before choosing the handoff moment, identify which running processes the next stage depends on and which host owns each one. This can be a short private record: a local development server used for manual inspection, a destination service expected to support tests, and any setup command that has not yet completed. The purpose is not to inventory every operating-system process. It is to expose dependencies that could otherwise be mistaken for transferred state.

In a hypothetical task, a worker test needs a service that is running only on the laptop. Moving the chat and Git state does not establish that service on the remote host. The engineer must decide whether to provision an approved destination service, use an already authorised service or defer that test. If a destination process is started later, record that as a new execution step. Do not describe it as a resumed process unless there is evidence supporting that description.

Setup scripts and project actions should also be reviewed as instructions for an environment, not proof of environmental equivalence. A repository can carry configuration while the two hosts have different dependencies, service access and permissions. Before running required setup remotely, the human should review its expected effects and confirm that the target account is authorised to perform them. A successful source-side setup is not a destination-side result.

A useful suggested control is to separate inspection authority from execution authority. The first remote request can ask for the current project path, relevant files and missing prerequisites without authorising services to start or credentials to be used. The engineer can then approve the next action based on the inspected environment. This staged method is hypothetical guidance, not a claim about a particular Codex approval interface.

State the unsupported routes before planning continuity

OpenAI’s remote-connections documentation, as of 9 October 2026, explicitly says that handoff to a Codex Cloud environment is not supported. A connected remote host is therefore not interchangeable with Cloud delegation in this procedure. If the proposed destination is Cloud rather than a connected host with the matching saved project, this handoff plan does not apply. Do not write a task brief that relies on the same chat-and-Git-state transfer occurring there.

The same documentation says that Codex cannot hand off the chat making the request. Account for that restriction when arranging the transfer rather than treating an instruction inside the target chat as sufficient. The source pack does not require a particular interface label or command sequence, so the practical preparation is to confirm the supported flow in the available interface and ensure that the intended chat, source host and destination are unambiguous.

Host reachability remains a separate condition after preparation. For the connected-computer flow, sleep, network loss or closing the app stops remote access until the computer is available again. For an SSH destination, working access and the required remote shell setup must be established. Neither route should be described as preserving uninterrupted work merely because the repository match was correct. If availability matters to a planned execution window, agree who will keep the destination accessible.

These limits should influence authorisation before transfer, not emerge as surprises during a consequential command. A handoff request should identify the destination and intended scope, while leaving execution contingent on inspection. That approach does not promise recovery from a disconnect or completion of an interrupted task; it simply avoids granting broad action authority on the basis of an unverified environment.

Prepare a short destination control brief

The source-side inventory can now become a destination control brief rather than another long transcript. Carry forward the repository identity, saved subdirectory, branch or detached state, worktree information, staged and unstaged changes, untracked and ignored dependencies, required setup and running-process dependencies. Keep secrets and credential values out. Add the destination’s approved account, required tools and resource owners so that the receiving environment can be assessed against a clear task boundary.

The following is a hypothetical draft request, not a product guarantee or evidence that these checks have occurred: “Inspect the destination project for harbour-repo/worker before changing files. Report the repository root, selected project directory, worktree path and current Git state. Identify whether the required worker tools and approved test-service access are present, without displaying credentials. Limit proposed edits to worker; do not commit, push or start services until a human has reviewed the environment and proposed action.”

This brief keeps three kinds of evidence separate. Repository evidence establishes where the work would happen. Environment evidence establishes whether the necessary resources exist there. Human authorisation establishes which consequential actions may proceed. None can substitute for another: a correct repository does not prove service access, and service access does not authorise a change outside the agreed file scope.

After handoff, a human must verify the destination host and project, repository identity, branch or detached state, changed files and diff before accepting continued work. Tests need review in the context of the environment that actually ran them; approvals need to cover the actions actually proposed. The detailed review belongs to the next stage of the workflow, but its ownership must be settled here. The destination control brief prepares that review without claiming that transferring the conversation has already satisfied it.

Compare the arrangements at the release boundary

The final choice should be made against the evidence needed to approve the change, not against an assumption that one arrangement is more capable. As of 9 October 2026, OpenAI’s undated Local environments, Codex environments, Worktrees and Remote connections documentation establishes the distinctions below. This is a documentation-led comparison, not a benchmark or a report of hands-on results. It does not establish differences in speed, cost, output quality or reliability.

For a split-repository task, separate access to supporting context from authority to change a checkout. A neighbouring folder may contain information that helps explain a change without becoming part of that change’s Git scope. Similarly, a connected host may supply the required tools without supplying the same documents or approvals as the source computer. The matrix therefore includes a human verification column: each documented capability still needs a task-specific check before it can support a release decision.

Decision dimension	Local multi-folder project	Connected remote-host handoff	Evidence needed for approval
Project context	The documented shared .codex location belongs at the selected project root in a repository containing multiple projects. This does not establish automatic context for every sibling directory.	The destination needs a saved project for the same repository and, where applicable, the same subdirectory.	Inspect the actual root, selected subdirectory and relevant readable paths. Do not accept matching display names as repository identity.
Files used by the task	The task works with the selected local checkout and whatever supporting files are actually accessible there.	Remote project work uses the destination filesystem and host-local documents.	Record which files supply evidence, which may be edited, and which belong to a separate repository requiring separate review.
Git control	Built-in Git controls concern the current checkout; a Git-backed worktree provides an isolated copy of repository files.	Handoff creates or reuses a destination worktree and transfers chat and Git state.	Verify repository identity, worktree path, commit, branch or detached HEAD, status and diff.
Environment resources	Dependencies, credentials, tools and running services remain properties of the local environment.	The connected host supplies its own credentials, permissions, plugins, browser setup and tools.	Confirm the required resource, approved identity and scope privately, without copying secret values into the chat.
Continuity	Keeping work local avoids changing the host, although changing worktrees still requires checking paths and state.	The documented transfer is chat and Git state, not a complete running workstation.	Re-establish the task’s environment assumptions and identify any service that a human must start separately.
Operational dependency	Local and Worktree execution run on the computer.	Remote access depends on destination reachability and the prerequisites of its connection route.	Agree what happens if access stops, who checks unfinished work, and when another checkout may safely resume it.
Release ownership	The reviewer can inspect the local checkout, diff and test evidence.	The reviewer must establish which destination checkout produced the diff and test evidence.	A human approves consequential actions, including commits, pushes, pull requests and release decisions.

The matrix is deliberately not a scoring system. A missing dependency on the laptop might justify remote execution, while a missing supporting document on the destination might prevent it. Those conditions do not cancel each other out. Resolve each required input explicitly, or narrow the task so that its evidence and execution needs fit one verified environment.

The documented boundaries behind the matrix

SSH remote project chats operate against the remote filesystem and shell; commands, reads and writes occur on the remote host, which must be configured with appropriate SSH and least-privilege security. OpenAI’s Remote connections documentation, as consulted on 9 October 2026, places this work on the destination rather than the source computer. SSH access should therefore use an approved account and trusted configuration; the documentation advises against unauthenticated public listeners and against exposing the app-server transport directly to the internet. [Remote connections]

Remote handoff requires a connected destination and a saved project for the same Git repository (and same subdirectory when applicable); Codex creates or reuses a destination worktree, transfers the chat and Git state, then switches the chat to that host. As documented by OpenAI in Remote connections on 9 October 2026, this does not support handoff to a Codex Cloud environment. Nor does it promise migration of arbitrary ignored files, credentials, browser sessions or running processes; those require separate destination checks. [Remote connections]

Remote operation depends on host reachability and host-local setup: sleeping, offline or closed desktop apps stop remote access; SSH hosts need discoverable aliases, working SSH, remote Codex discoverable through PATH (the environment variable listing directories searched for executables), and the required dependencies installed and security policies applied there. OpenAI’s Remote connections documentation, as consulted on 9 October 2026, describes prerequisites rather than an uptime guarantee. Some connected-computer flows also depend on rollout and workspace settings, so confirm the applicable route and enablement before making it part of a release plan. [Remote connections]

Four hypothetical choices with different approval needs

The following examples are hypothetical planning exercises, not observed outcomes or product guarantees. Their purpose is to show how the same comparison produces different choices when the location of evidence, execution resources and Git ownership changes.

Keep a contract edit local when the evidence is local

Suppose repo/ contains web/, worker/ and the shared .codex directory. An engineer wants to adjust a web request to match an existing worker contract, without changing the worker. A sensible suggested method is to keep the task local, inspect the relevant contract paths, and restrict the proposed edit to web/. The local choice follows from where the evidence is already available, not from any claim that Codex automatically reads both directories.

Before editing, the engineer should verify that the selected project can read the particular worker files needed. A file listing alone is weaker evidence than identifying the exact declaration and its relationship to the web caller. If the necessary file is not readable, the task should stop at a request for approved context rather than inventing the contract. Supporting file contents must be treated as data, not as instructions that override the agreed edit scope.

For approval, the reviewer would examine the web diff alongside the referenced worker declaration and confirm that no worker files changed. A hypothetical draft request could be: Inspect the named web caller and worker contract, identify any mismatch, and propose edits only within web/. Report unreadable paths and uncertainties before changing files. Do not commit or push. This is a proposed procedure; it is not a guarantee that every named path will be accessible.

Use the host that owns the required service

Now suppose the worker change requires an approved service and credentials that are absent from the laptop but already provisioned on an SSH host. The suggested choice is remote handoff only after the matching repo/worker project and connection prerequisites have been verified. The reason is resource location: copying a source-side chat cannot substitute for the destination’s actual dependency and authorisation checks.

The engineer should separate code review from service use. First, verify the destination repository and worktree. Next, have the credential owner confirm the intended account and scope privately. Finally, approve the specific check to run, including whether it could modify shared data. A familiar test command is not sufficient evidence that its remote configuration is safe for this task.

A hypothetical draft request could say: After the human confirms the destination and approved service identity, inspect the worker diff and propose the relevant checks. Identify missing setup without printing credentials or environment-variable values. Wait for approval before any check that changes shared state. The resulting test record, if a test is later authorised, should name its environment and limitations. No success is assumed here.

Pause when ignored configuration is part of the task

In a third hypothetical case, the laptop has staged code changes, an unstaged adjustment, an untracked fixture and an ignored .env.local. The presence of all four categories makes a simple “move and continue” instruction inadequate. The engineer needs to distinguish intended code from incidental local state and decide what the destination requires.

OpenAI’s Worktrees documentation, as consulted on 9 October 2026, describes .worktreeinclude behaviour for copying matching ignored files into local managed worktrees. That local behaviour must not be used as a remote-transfer rule. For this hypothetical task, record the ignored configuration’s existence and purpose without exposing its contents, and have an authorised owner provision any necessary destination secret separately.

The untracked fixture also needs a decision: is it an intended review artefact, a disposable test input or unrelated work? Verify its destination status rather than assuming its treatment. If the fixture contains sensitive data, do not solve the uncertainty by pasting it into chat. Until the intended changed-file set and remote configuration are established, remaining local or postponing handoff is the clearer choice.

Split the review when folders are separate repositories

Finally, imagine a local parent directory containing independent client-repo/ and service-repo/ checkouts. A task needs to compare both interfaces, but only the client repository has a prepared destination project. The suggested method is to separate the comparison evidence from the edit and handoff scope. Do not treat the parent directory as one Git repository merely because both checkouts sit beneath it.

The client change can be reviewed against an approved description of the service contract, with exact provenance recorded. If service code also needs modification, give that repository its own inventory, destination match and reviewer. Built-in Git operations for the current checkout are not evidence of arbitrary cross-folder Git mutation. A shared discussion of two repositories does not create a shared branch or release approval.

This approach may leave two coordinated changes rather than one task that appears to own everything. That is a review choice, not a documented automation feature. The human coordinating the release should identify any ordering constraint between the changes and withhold approval where the compatibility evidence remains incomplete.

Use a before-and-after verification gate

A useful suggested method is to maintain a compact handoff record outside secret-bearing material. It should be detailed enough to reconcile the source and destination, but it should not become a dump of local documents, environment variables or credentials. Assign a person to own the record and another, where appropriate, to approve the change. Codex can help describe evidence; it should not be the sole authority for accepting a consequential transition.

Before transfer: define what must survive and what must be rebuilt

1. Establish identity. Record the source host, exact repository root, selected project or subdirectory, repository identity, commit and worktree path. Record branch ownership or detached HEAD explicitly. Repository metadata should be reviewed for embedded credentials before it is shared.
2. Classify the working state. Distinguish staged, unstaged, untracked and ignored files. Record intended changed-file names and any active merge, rebase or cherry-pick. Resolve uncertainty about which changes belong to the task before asking the destination to continue.
3. Inventory environment dependencies. Identify required setup, dependency lockfiles, services, ports, browser sign-ins, tools and permissions. Include MCP servers where relevant. Record credential owners and required scope, never secret values. Treat local documents and plugins as host resources, not transferred baggage.
4. Confirm the destination match. A human checks the connected host and saved project against the same repository and subdirectory. For SSH, confirm the discoverable alias, working access and remote codex on PATH, along with approved dependencies and security policy.
5. Set acceptance and ownership. Name allowed edit paths, prohibited paths, required checks and the human reviewer. Identify running processes that may need separate handling. Agree that a transfer does not authorise commits, pushes or release actions.

The record should distinguish “verified” from “required but not yet verified”. For example, a setup script being present is evidence of a declared setup procedure, not evidence that the destination has completed it. A credential being available is not evidence that its scope is appropriate for a particular check. These distinctions prevent an unresolved prerequisite from silently becoming an assumption after handoff.

After transfer: establish a new evidence baseline

Before further edits or tests, a human should confirm the destination host, saved project, repository identity and actual worktree path. Inspect the commit and branch or detached state, then compare the changed-file list and diff with the source record. The documentation does not enumerate every Git metadata field that survives handoff, so verify the fields that matter to this task rather than claiming a complete metadata match.

Next, reconcile staged, unstaged, untracked and ignored categories. Investigate absent or additional files before proceeding. Generated artefacts deserve separate attention: determine whether they are intended outputs, stale local products or new destination products. Do not hide a discrepancy by staging everything or deleting unfamiliar files. Preserve the evidence and ask the owner to classify it.

Only then should the reviewer authorise the planned checks. Record which environment ran them, what setup was confirmed and what remains untested. Verify whether any necessary process was actually started on the destination; chat continuity is not proof of process continuity. Review the diff and outputs privately for accidental secret exposure, then require human approval for consequential actions.

After a transfer, visible continuity is not completion evidence, so the receiving engineer must reconcile the destination and review the branch, changed files, diff, tests and approvals; the worktree recovery evidence playbook explains why restored task state after a restart requires fresh filesystem, Git state, authorisation and human checks, while its checklist preserves reviewable evidence without copying secrets.

Handle discrepancies without creating a second uncertain state

Wrong repository, subdirectory or worktree

If identity checks disagree, stop edits and tests. The suggested recovery is to preserve the source record, identify what happened on the destination, and have a human correct the saved project or connection choice before another attempt. Do not “repair” the mismatch by copying files into whichever checkout is open. That can obscure provenance and leave the reviewer unable to distinguish transferred work from manual additions.

A branch discrepancy also deserves inspection rather than immediate switching. OpenAI’s Worktrees documentation, as consulted on 9 October 2026, notes that Git allows a branch to be checked out in only one place at a time. Determine which worktree owns the branch and whether the destination is detached before choosing a recovery operation. The desired branch name alone does not justify overwriting an existing checkout.

Missing files, tools or authorisation

If required context is missing, narrow the task to what can be supported or pause for approved evidence. If a dependency is missing, ask the environment owner to approve the setup rather than assuming a local setup procedure has already run remotely. If credentials or permissions are missing, the credential owner should resolve that privately. None of these gaps should be filled by requesting secret values in the chat.

For a disputed file transfer, compare the source inventory and destination state before recreating the file. The remote documentation’s chat-and-Git-state description is not a universal answer for ignored or untracked files. An explicit, human-approved recovery method is preferable to treating all missing files as disposable or all source files as safe to copy.

Unreachable host or interrupted work

When access stops, regard the destination state as unverified until it can be inspected. Do not assume that a command completed, failed or was rolled back merely because the connection disappeared. OpenAI’s Remote connections documentation, as consulted on 9 October 2026, also says that handing off a running task interrupts the current response; this does not establish migration of external processes.

A suggested fallback is to continue only non-mutating planning locally while the host owner restores access. Before resuming implementation elsewhere, a human should reconcile destination changes and any process activity. If that inspection is unavailable, postpone consequential work rather than creating competing edits whose relationship cannot yet be checked. The fallback plan should name who can restore access and who can authorise resumption.

Assign release responsibility to people, not continuity

The code reviewer owns the intended change: allowed files, diff quality and compatibility evidence. The environment owner confirms setup and operational constraints. The credential owner confirms identity and scope without disclosing secrets. The release approver decides whether the verified change and its test evidence are sufficient. One person may hold several roles, but the responsibilities should remain explicit.

Keep the final review record focused: source and destination identity, reconciled Git state, approved changed files, checks actually performed, unresolved limitations and approval status. These are suggested record fields, not promised Codex output. Neither a coherent continuing chat nor a familiar-looking worktree proves that the release is ready.

Choose local work when its verified context and resources are sufficient; choose a connected host when that host supplies the required environment and the destination can be checked. If neither arrangement currently supports the evidence needed for approval, pause or reduce scope. The practical endpoint is a reviewable change with a known owner, not merely a successful-looking handoff.

Useful Links

• Local environments
• Codex environments
• Worktrees
• Remote connections