Reconstructing Environments From Trajectories

Given a directory of terminal/code-agent trajectories (tool-call logs with file reads/writes/edits and shell commands), turn each into a reusable environment:

1. Parse trajectory τ into an ordered list of file/tool operations.
2. Replay operations, but for every Write/Edit, restore the pre-edit file content (found in preceding Read or diff context) instead of the agent's final version — this yields a partial, unsolved workspace.
3. Run a completion agent over the partial workspace to synthesize missing files, configs, and dependencies (without ever revealing the agent's original fix).
4. Validate the workspace boots/builds; if not, iterate completion.
5. Re-query the environment: reconstruct the original task, synthesize new single-workspace tasks, cross-workspace tasks, and multi-round sessions.
6. Attach an agent-authored executable verifier to each new task; discard any task-trajectory pair whose tests don't pass.

Progress:

• Step 1: Ingest trajectory and extract tool-execution history (Read/Write/Edit/Bash calls)
• Step 2: Deterministic replay — roll back agent's own edits to reconstruct pre-agent file states
• Step 3: Agentic completion — fill gaps (missing files, deps, configs) without solution leakage
• Step 4: Sanity-check the recovered workspace is executable
• Step 5: Re-query — generate tasks along vanilla, breadth (cross-workspace), and depth (multi-round) axes
• Step 6: Verify — agent writes an executable test/verifier for each new task
• Step 7: Filter — keep only environments where solved trajectories pass all verifiers

Step 1 — Extract tool-execution history. Parse the trajectory into a sequence of typed operations. Read(path) reveals file content at that point in time; Write(path, content) / Edit(path, diff) reveal both prior and posterior states. Preserve ordering — later replay depends on operation sequence, not just final diffs.

Step 2 — Deterministic replay. For every file the agent touched, reconstruct the version that existed before the agent's first modification (using the content shown in the earliest Read, or by inverting the recorded diff). Do NOT replay the agent's own fix — that's the solution, and leaking it defeats the purpose of building a re-solvable environment. The result is a partial workspace: correct in structure, but missing anything the agent never touched (e.g., untouched sibling files, lockfiles, hidden config).

Step 3 — Agentic completion. Because replay only recovers what appears in the trajectory, dispatch a completion agent to inspect the partial workspace (imports that resolve to nothing, config referencing absent files, package manifests without lockfiles) and generate the missing pieces plausibly. Constrain this agent explicitly: it must not reconstruct or hint at the original fix, only supply neutral scaffolding/dependencies needed for the workspace to run.

Step 4 — Sanity-check. Attempt to build/boot the workspace (install deps, run existing tests if any). If it fails, feed the error back into the completion agent for another pass. Cap retries; discard environments that never stabilize.

Step 5 — Re-query (task synthesis). Generate tasks in four modes:

• Reconstructed intent: recover the original task the trajectory was solving.
• New single-workspace task: propose a different task on the same recovered workspace.
• Breadth (cross-workspace): mine directional dependency relations between environments recovered from related trajectories (e.g., one project references or could import from another) and synthesize tasks spanning multiple workspaces — porting a feature, wiring two components together, using one repo as a reference implementation for another.
• Depth (multi-round): after an initial task is solved, run a user-simulator agent that inspects the resulting workspace state and issues a grounded follow-up — either a new requirement building on the change, or (if verification failed) a fix request referencing the actual failure. Repeat for several rounds, feeding real verifier output back as user-visible feedback each round.

Step 6 — Verification. For every synthesized task, have an agent write an executable verifier (tests, assertions, or scripted checks) inside the container, grounded in the actual recovered workspace state, not the abstract task description.

Step 7 — Filter. Roll out a candidate solution (e.g., with a strong teacher model) against each task; run the verifier. Keep only (environment, task, verifier) triples where all checks pass. Discard everything else rather than trying to fix it — filtering is cheaper and safer than debugging synthetic tasks.

Example 1: Single trajectory → reusable environment Input: A trajectory shows Read("src/utils.py") returning old content, then Edit("src/utils.py", diff) adding a caching decorator, then Bash("pytest tests/test_utils.py") passing. Output: Recovered workspace contains src/utils.py in its pre-edit state (no caching decorator). Completion agent notices tests/test_utils.py imports pytest_cache_helpers, which was never read/written in the trajectory, and generates a plausible stub/dependency for it so the test suite is importable. Original task reconstructed as: "Add caching to utils.py functions to reduce redundant computation; existing tests must pass."

Example 2: Breadth expansion Input: Two recovered environments — Repo A (a logging library) and Repo B (a web service) — where B's trajectory history shows it referencing patterns similar to A's public API. Output: New cross-workspace task: "Port the structured-logging module from Repo A into Repo B's request pipeline, replacing its ad-hoc print statements, while keeping Repo B's existing tests green." Verifier checks Repo B's test suite plus new assertions that log output is structured JSON.

Example 3: Depth expansion Input: Round 1 task "Fix the null-pointer bug in parse_config" is solved and verified. Output: User-agent inspects the diff, sees parse_config now handles nulls but ignores malformed YAML, and issues Round 2: "Now that nulls are handled, can you also make it raise a clear error on malformed YAML instead of crashing?" New verifier added for the YAML-error case; both rounds' verifiers must pass together.