From 72bf8d106f745a44845903eb9b238b1e1b4faf3f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Oscar=20Nordstr=C3=B6m?= <13300531+n0rpan@users.noreply.github.com> Date: Mon, 16 Nov 2026 10:01:41 +0000 Subject: [PATCH] Continue retained task branches with sandboxed base merges (#333) --- oxa/docs/work.md | 30 ++- oxa/oxa-cli/src/work_checks.rs | 34 ++- oxa/oxa-cli/tests/common/work.rs | 82 ++++++ oxa/oxa-cli/tests/work_cli.rs | 24 +- oxa/oxa-cli/tests/work_continue.rs | 390 +++++++++++++++++++++++++++++ oxa/oxa-work/src/lib.rs | 138 +++++----- oxa/oxa-work/src/tree.rs | 230 +++++++++++++++++ 7 files changed, 840 insertions(+), 88 deletions(-) create mode 100644 oxa/oxa-cli/tests/common/work.rs create mode 100644 oxa/oxa-cli/tests/work_continue.rs create mode 100644 oxa/oxa-work/src/tree.rs diff --git a/oxa/docs/work.md b/oxa/docs/work.md index 26c5048de..73e973578 100644 --- a/oxa/docs/work.md +++ b/oxa/docs/work.md @@ -8,8 +8,9 @@ Run it inside the project repository. The JSON file is an array: ``` `base` defaults to `main`. IDs contain letters, digits, hyphens or underscores. -IDs and branches must be unique; branches must be new. For a GitHub issue use -`oxa work --issue 123 --model your-model`. This explicitly invokes your installed, +IDs and branches must be unique within one file. Existing task branches can be +continued. For a GitHub issue use `oxa work --issue 123 --model your-model`. +This explicitly invokes your installed, authenticated `gh` CLI to fetch the issue title and body. Issue lookup is refused when the environment or user settings enable offline mode. Issue lookup also requires source-project trust. Git and GitHub CLI host calls use @@ -59,21 +60,34 @@ JSON lines include the worker result, session ID and captured `base_sha` and rep commits or file changes), `red` (checks still fail), or `blocked` (setup or agent execution failed). Exit codes are 0 for success, 1 if any task is red or blocked, and 2 for invalid input or output errors. A task setup failure produces a blocked -JSON line and does not skip later tasks. If a task cannot be locked or already has -a receipt, its existing state is preserved; a pre-worktree failure has an empty -`worktree` in the result. Locks use kernel ownership, so an abandoned lock file +JSON line and does not skip later tasks. If a task cannot be locked or has an +incompatible receipt, its existing state is preserved; a pre-worktree failure has +an empty `worktree` in the result. Locks use kernel ownership, so an abandoned lock file after process death does not permanently block a task. Worktrees and uncommitted changes remain in `.oxa-worktrees//` beside the repository (or the separate git directory). Private result receipts and locks live under `~/.oxa/agent/work//` (or the configured agent -directory), outside the worker's writable Git bind. Receipts are published atomically -without overwriting an existing receipt. Worktrees stay outside that git +directory), outside the worker's writable Git bind. New receipts are published +atomically without overwriting an existing receipt; a validated matching receipt +is replaced atomically under the task lock when continuing. Worktrees stay outside that git directory so the normal sandbox can bind git objects and refs for commits. No automatic -cleanup, commit, push, PR creation or continuation is implemented yet. Inspect +cleanup, commit, push or PR creation is implemented yet. Inspect retained work before removing it with `git worktree remove`. Review task prompts and bases before running them. `done` here describes accepted local work, which may be uncommitted. This slice does not publish it. The saving/publication slices must bind acceptance to a clean committed tree and verify its recorded commit before pushing. + +To continue a task, run the same task file again. A matching retained receipt and +linked worktree are reused. The source checkout is never used as the task worktree. +An existing branch checked out elsewhere is blocked. Dirty retained work is kept +and blocked until committed. A clean retained branch gets an ordinary sandboxed +merge of the captured base; no reset, stash, force checkout or automatic fetch runs. + +An unfinished merge is passed to the worker with its old pending commit, the +captured current base and at most twenty conflicted paths. The worker must finish +that merge and merge the captured base too. Aborted or unresolved merges and branch +switches remain blocked even if acceptance passes. Worker, merge and acceptance +failures are retained together. Receipt replacement keeps private modes. diff --git a/oxa/oxa-cli/src/work_checks.rs b/oxa/oxa-cli/src/work_checks.rs index 090ba813e..e2a3a3ffa 100644 --- a/oxa/oxa-cli/src/work_checks.rs +++ b/oxa/oxa-cli/src/work_checks.rs @@ -27,13 +27,14 @@ pub(crate) fn run( let settings = Settings::load(dirs, &source, true); let commands = match request.operation { SupervisorOperation::Inspect => return inspect(&b, &root), - SupervisorOperation::Checkout { branch } => { + SupervisorOperation::Checkout { branch, create } => { let sandbox = crate::netguard::with_net(Arc::new(b), &settings); let spec = ExecSpec { - command: format!( - "git --no-replace-objects checkout HEAD -- . && git --no-replace-objects checkout -b '{}' HEAD", - branch.replace('\'', "'\\''") - ), + command: if create { + format!("git --no-replace-objects checkout HEAD -- . && git --no-replace-objects checkout -b '{}' HEAD", branch.replace('\'', "'\\''")) + } else { + "git --no-replace-objects checkout HEAD -- .".into() + }, cwd: root, writable: true, net: sandbox.network(), @@ -54,6 +55,29 @@ pub(crate) fn run( } return Ok(0); } + SupervisorOperation::Merge { base } => { + let sandbox = crate::netguard::with_net(Arc::new(b), &settings); + let spec = ExecSpec { + command: format!( + "git --no-replace-objects merge --no-edit -- '{}'", + base.replace('\'', "'\\''") + ), + cwd: root, + writable: true, + net: sandbox.network(), + timeout_s: Some(600), + env: git_environment(), + }; + let mut tail = Vec::new(); + let result = sandbox.run_streaming(&spec, &CancelToken::default(), &mut |bytes| { + keep_tail(&mut tail, bytes, 8192); + }); + err.write_all(&tail).map_err(|e| e.to_string())?; + if result.timed_out || result.exit.is_none() { + return Err("sandboxed base merge did not complete; worktree retained".into()); + } + return Ok(i32::from(result.exit != Some(0))); + } SupervisorOperation::Checks { commands } => commands, }; let shell = oxa_tools::ShellConfig { diff --git a/oxa/oxa-cli/tests/common/work.rs b/oxa/oxa-cli/tests/common/work.rs new file mode 100644 index 000000000..59d09defa --- /dev/null +++ b/oxa/oxa-cli/tests/common/work.rs @@ -0,0 +1,82 @@ +use oxa_fake::{FakeOpts, FakeServer, ScriptTurn, TestEnv}; +use std::{path::Path, process::Command}; +pub fn git(env: &TestEnv, dir: &Path, args: &[&str]) -> String { + let out = Command::new("git") + .args(args) + .current_dir(dir) + .env_clear() + .envs(env.envs("http://127.0.0.1:1")) + .env("GIT_AUTHOR_NAME", "Test") + .env("GIT_AUTHOR_EMAIL", "test@example.invalid") + .env("GIT_COMMITTER_NAME", "Test") + .env("GIT_COMMITTER_EMAIL", "test@example.invalid") + .output() + .unwrap(); + assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr)); + String::from_utf8_lossy(&out.stdout).trim().into() +} +pub fn setup(env: &TestEnv, done: &str) { + git(env, &env.work(), &["init", "--bare", "remote.git"]); + git(env, &env.work(), &["init", "-b", "main", "project"]); + let project = env.work().join("project"); + git(env, &project, &["config", "user.name", "Test"]); + git(env, &project, &["config", "user.email", "test@example.invalid"]); + env.write( + "work/project/.oxa/settings.json", + &format!(r#"{{"done":{done}}}"#), + ); + git(env, &project, &["add", "."]); + git(env, &project, &["commit", "-m", "fixture"]); + git(env, &project, &["remote", "add", "origin", "../remote.git"]); + git(env, &project, &["push", "origin", "main"]); + oxa_perm::TrustStore::default() + .save(&env.agent_dir().join("trust.json"), &project, true) + .unwrap(); + env.write( + "work/tasks.json", + r#"[{"id":"test","branch":"agent/test","model":"fake","prompt":"Finish task"}]"#, + ); +} +pub fn run(env: &TestEnv, turns: Vec) -> serde_json::Value { + run_args(env, turns, &["work", "../tasks.json"], None) +} +pub fn run_args( + env: &TestEnv, + turns: Vec, + args: &[&str], + path: Option, +) -> serde_json::Value { + run_observed(env, turns, args, path).0 +} +pub fn run_observed( + env: &TestEnv, + turns: Vec, + args: &[&str], + path: Option, +) -> (serde_json::Value, Vec) { + let server = FakeServer::start(turns, FakeOpts::default()).unwrap(); + let mut command = Command::new(env!("CARGO_BIN_EXE_oxa")); + command + .args(args) + .current_dir(env.work().join("project")) + .env_clear() + .envs(env.envs(&server.url())); + if let Some(path) = path { + command.env("PATH", path); + } + let (tx, rx) = std::sync::mpsc::channel(); + std::thread::spawn(move || { + tx.send(command.output().unwrap()).unwrap(); + }); + let out = rx + .recv_timeout(std::time::Duration::from_secs(90)) + .expect("runner finished"); + let record = serde_json::from_slice(&out.stdout).unwrap_or_else(|e| { + panic!( + "{e}: {} / {}", + String::from_utf8_lossy(&out.stdout), + String::from_utf8_lossy(&out.stderr) + ) + }); + (record, server.requests()) +} diff --git a/oxa/oxa-cli/tests/work_cli.rs b/oxa/oxa-cli/tests/work_cli.rs index ddd884be8..0f222ac4c 100644 --- a/oxa/oxa-cli/tests/work_cli.rs +++ b/oxa/oxa-cli/tests/work_cli.rs @@ -243,13 +243,31 @@ printf '%s' '{"title":"Synthetic task","body":"Fix the test fixture"}' assert_eq!(record["outcome"], "nothing_to_do", "{record}"); } #[test] -fn setup_failure_records_blocked_and_keeps_existing_branch() { +fn branch_checked_out_elsewhere_is_blocked_without_changing_it() { let env = TestEnv::new(); setup(&env, "[]"); - git(&env, &env.work().join("project"), &["branch", "agent/test"]); + let project = env.work().join("project"); + git(&env, &project, &["branch", "agent/test"]); + let original = git(&env, &project, &["rev-parse", "agent/test"]); + let occupied = env.work().join("occupied"); + git( + &env, + &project, + &["worktree", "add", occupied.to_str().unwrap(), "agent/test"], + ); let record = run(&env, vec![]); assert_eq!(record["outcome"], "blocked", "{record}"); - assert!(record["detail"].as_str().unwrap().contains("already exists")); + assert!( + record["detail"] + .as_str() + .unwrap() + .contains(occupied.to_str().unwrap()), + "{record}" + ); + assert!(record["worker"].is_null()); + assert!(!env.work().join(".oxa-worktrees/project/test").exists()); + assert_eq!(git(&env, &occupied, &["rev-parse", "HEAD"]), original); + assert_eq!(git(&env, &project, &["symbolic-ref", "--short", "HEAD"]), "main"); } #[test] diff --git a/oxa/oxa-cli/tests/work_continue.rs b/oxa/oxa-cli/tests/work_continue.rs new file mode 100644 index 000000000..a0d7de429 --- /dev/null +++ b/oxa/oxa-cli/tests/work_continue.rs @@ -0,0 +1,390 @@ +//! Continued branches merge the base before the real child agent starts. +#[path = "common/work.rs"] +mod work; +use oxa_fake::{ScriptTurn, TestEnv}; +use std::path::{Path, PathBuf}; +use work::{git, run, run_observed, setup}; + +fn project(env: &TestEnv) -> PathBuf { + env.work().join("project") +} +fn commit_file(env: &TestEnv, file: &str, content: &str) { + env.write(&format!("work/project/{file}"), content); + git(env, &project(env), &["add", file]); + git(env, &project(env), &["commit", "-m", "fixture update"]); +} +fn diverge(env: &TestEnv, conflict: bool) { + setup(env, "[]"); + commit_file(env, "shared.txt", "original\n"); + git(env, &project(env), &["checkout", "-b", "agent/test"]); + commit_file(env, "shared.txt", "task version\n"); + git(env, &project(env), &["checkout", "main"]); + commit_file( + env, + if conflict { "shared.txt" } else { "base.txt" }, + "base version\n", + ); +} +fn tree(record: &serde_json::Value) -> &Path { + Path::new(record["worktree"].as_str().unwrap()) +} +fn merge_head(env: &TestEnv, root: &Path) -> PathBuf { + PathBuf::from(git( + env, + root, + &["rev-parse", "--path-format=absolute", "--git-path", "MERGE_HEAD"], + )) +} +fn resolve_turns() -> Vec { + vec![ + ScriptTurn::tool( + "resolve", + "write", + r#"{"path":"shared.txt","content":"resolved\n"}"#, + ), + ScriptTurn::tool( + "commit", + "bash", + r#"{"command":"git add shared.txt && git commit --no-edit"}"#, + ), + ScriptTurn::text("merge finished"), + ] +} +fn trust(env: &TestEnv) { + env.write( + "home/.oxa/agent/settings.json", + r#"{"defaultProjectTrust":"always"}"#, + ); +} +#[test] +fn existing_branch_fast_forwards_to_base_before_agent() { + let env = TestEnv::new(); + setup(&env, "[]"); + git(&env, &project(&env), &["branch", "agent/test"]); + commit_file(&env, "base.txt", "from main\n"); + let record = run(&env, vec![ScriptTurn::text("nothing")]); + assert_eq!(record["outcome"], "nothing_to_do", "{record}"); + assert_eq!( + std::fs::read_to_string(tree(&record).join("base.txt")).unwrap(), + "from main\n" + ); + git( + &env, + &project(&env), + &["merge-base", "--is-ancestor", "main", "agent/test"], + ); +} +#[test] +fn divergent_branch_gets_normal_merge_without_losing_task_commit() { + let env = TestEnv::new(); + diverge(&env, false); + let record = run(&env, vec![ScriptTurn::text("nothing")]); + assert_eq!(record["outcome"], "nothing_to_do", "{record}"); + assert_eq!( + git(&env, tree(&record), &["rev-list", "--parents", "-n", "1", "HEAD"]) + .split_whitespace() + .count(), + 3 + ); + assert_eq!( + std::fs::read_to_string(tree(&record).join("shared.txt")).unwrap(), + "task version\n" + ); + assert!(tree(&record).join("base.txt").exists()); +} +#[test] +fn conflicts_reach_agent_with_merge_in_progress_and_stay_blocked_if_unresolved() { + let env = TestEnv::new(); + diverge(&env, true); + let (record, requests) = run_observed( + &env, + vec![ScriptTurn::text("cannot resolve")], + &["work", "../tasks.json"], + None, + ); + assert_eq!(record["outcome"], "blocked", "{record}"); + assert!(record["detail"].as_str().unwrap().contains("merge")); + assert!(merge_head(&env, tree(&record)).exists()); + assert!(std::fs::read_to_string(tree(&record).join("shared.txt")) + .unwrap() + .contains("<<<<<<<")); + let user = requests + .iter() + .flat_map(|r| &r.messages) + .filter_map(|m| m.content.as_deref()) + .collect::>() + .join("\n"); + assert!( + user.contains("Finish task") && user.contains("merge in progress") && user.contains("shared.txt"), + "{user}" + ); +} +#[test] +fn agent_can_resolve_and_commit_merge_inside_real_sandbox() { + let env = TestEnv::new(); + diverge(&env, true); + trust(&env); + let record = run(&env, resolve_turns()); + assert_eq!(record["outcome"], "done", "{record}"); + assert!(!merge_head(&env, tree(&record)).exists()); + assert_eq!( + std::fs::read_to_string(tree(&record).join("shared.txt")).unwrap(), + "resolved\n" + ); + assert_eq!( + std::fs::read_to_string(project(&env).join("shared.txt")).unwrap(), + "base version\n" + ); +} +#[test] +fn unresolved_merge_can_be_continued_without_resetting_it() { + let env = TestEnv::new(); + diverge(&env, true); + trust(&env); + let first = run(&env, vec![ScriptTurn::text("blocked")]); + assert_eq!(first["outcome"], "blocked", "{first}"); + let second = run(&env, resolve_turns()); + assert_eq!(second["outcome"], "done", "{second}"); + assert!(!merge_head(&env, tree(&second)).exists()); +} +#[test] +fn dirty_retained_worktree_is_blocked_without_dropping_edits() { + let env = TestEnv::new(); + setup(&env, "[]"); + trust(&env); + let first = run( + &env, + vec![ + ScriptTurn::tool("write", "write", r#"{"path":"notes.txt","content":"keep me"}"#), + ScriptTurn::text("done"), + ], + ); + assert_eq!(first["outcome"], "done", "{first}"); + let (record, requests) = run_observed(&env, vec![], &["work", "../tasks.json"], None); + assert_eq!(record["outcome"], "blocked", "{record}"); + assert!(requests.is_empty()); + assert_eq!( + std::fs::read_to_string(tree(&record).join("notes.txt")).unwrap(), + "keep me" + ); +} +#[test] +fn continued_branch_cannot_replace_base_acceptance_commands() { + let env = TestEnv::new(); + setup(&env, r#"["echo base-acceptance; exit 1"]"#); + git(&env, &project(&env), &["checkout", "-b", "agent/test"]); + commit_file(&env, ".oxa/settings.json", r#"{"done":[]}"#); + git(&env, &project(&env), &["checkout", "main"]); + let record = run( + &env, + vec![ScriptTurn::text("done"), ScriptTurn::text("still done")], + ); + assert_eq!(record["outcome"], "red", "{record}"); + assert!(record["detail"].as_str().unwrap().contains("base-acceptance")); +} + +#[test] +fn aborting_merge_cannot_report_green() { + let env = TestEnv::new(); + diverge(&env, true); + trust(&env); + let record = run( + &env, + vec![ + ScriptTurn::tool("abort", "bash", r#"{"command":"git merge --abort"}"#), + ScriptTurn::text("done"), + ], + ); + assert_eq!(record["outcome"], "blocked", "{record}"); + assert!(record["detail"].as_str().unwrap().contains("base is not merged")); +} +#[test] +fn changing_branch_cannot_report_green_for_task_branch() { + let env = TestEnv::new(); + setup(&env, "[]"); + trust(&env); + let record = run( + &env, + vec![ + ScriptTurn::tool("switch", "bash", r#"{"command":"git checkout -b alternate"}"#), + ScriptTurn::text("done"), + ], + ); + assert_eq!(record["outcome"], "blocked", "{record}"); + assert!(record["detail"].as_str().unwrap().contains("different branch")); +} + +#[test] +fn resumed_old_merge_is_told_to_integrate_the_newly_captured_base() { + let env = TestEnv::new(); + diverge(&env, true); + trust(&env); + let first = run(&env, vec![ScriptTurn::text("blocked")]); + assert_eq!(first["outcome"], "blocked", "{first}"); + let old_base = git(&env, &project(&env), &["rev-parse", "main"]); + commit_file(&env, "new-base.txt", "new base commit\n"); + let new_base = git(&env, &project(&env), &["rev-parse", "main"]); + let mut turns = resolve_turns(); + turns.insert( + 2, + ScriptTurn::tool( + "latest", + "bash", + &serde_json::json!({"command": format!("git merge --no-edit {new_base}")}).to_string(), + ), + ); + let (record, requests) = run_observed(&env, turns, &["work", "../tasks.json"], None); + assert_eq!(record["outcome"], "done", "{record}"); + let messages = requests + .iter() + .flat_map(|r| &r.messages) + .filter_map(|m| m.content.as_deref()) + .collect::>() + .join("\n"); + assert!( + messages.contains(&old_base) && messages.contains(&format!("git merge --no-edit {new_base}")), + "{messages}" + ); + assert!(tree(&record).join("new-base.txt").exists()); + git( + &env, + &project(&env), + &["merge-base", "--is-ancestor", &new_base, "agent/test"], + ); +} + +#[test] +fn failed_worker_and_unfinished_merge_keep_both_causes() { + let env = TestEnv::new(); + diverge(&env, true); + env.write( + "work/tasks.json", + r#"[{"id":"test","branch":"agent/test","model":"missing-model","prompt":"Finish task"}]"#, + ); + let record = run(&env, vec![]); + assert_eq!(record["outcome"], "blocked", "{record}"); + let detail = record["detail"].as_str().unwrap(); + assert!(detail.contains("missing-model"), "{detail}"); + assert!(detail.contains("merge remains in progress"), "{detail}"); + assert_eq!(record["worker"]["outcome"], "failed", "{record}"); +} + +#[test] +fn retained_task_alias_cannot_reuse_the_source_checkout() { + use std::os::unix::fs::symlink; + let env = TestEnv::new(); + setup(&env, "[]"); + git(&env, &project(&env), &["checkout", "-b", "agent/test"]); + let trees = env.work().join(".oxa-worktrees/project"); + std::fs::create_dir_all(&trees).unwrap(); + symlink(project(&env), trees.join("test")).unwrap(); + let (record, requests) = run_observed( + &env, + vec![ + ScriptTurn::tool( + "write", + "write", + r#"{"path":"source-escape","content":"escaped"}"#, + ), + ScriptTurn::text("done"), + ], + &["work", "../tasks.json"], + None, + ); + assert_eq!(record["outcome"], "blocked", "{record}"); + assert!(requests.is_empty()); + assert!(!project(&env).join("source-escape").exists()); +} + +#[test] +fn automatic_merge_hooks_stay_inside_the_sandbox() { + use std::os::unix::fs::PermissionsExt; + let env = TestEnv::new(); + diverge(&env, false); + let hook = env.write( + "work/project/.git/hooks/post-merge", + "#!/bin/sh\nprintf escaped > \"$HOME/continuation-hook-escape\" 2>/dev/null || true\nprintf ran > post-merge-ran\n", + ); + std::fs::set_permissions(hook, std::fs::Permissions::from_mode(0o755)).unwrap(); + let record = run(&env, vec![ScriptTurn::text("nothing")]); + assert!(!env.home().join("continuation-hook-escape").exists(), "{record}"); + assert_eq!(record["outcome"], "done", "{record}"); + assert_eq!( + std::fs::read_to_string(tree(&record).join("post-merge-ran")).unwrap(), + "ran" + ); + assert!(!project(&env).join("post-merge-ran").exists()); +} + +#[test] +fn post_worker_merge_verification_does_not_run_clean_filters_on_the_host() { + let env = TestEnv::new(); + setup(&env, "[]"); + trust(&env); + env.write("work/project/.gitattributes", "*.data filter=probe\n"); + env.write("work/project/fixture.data", "before\n"); + env.write("work/project/filter.sh", "cat\n"); + git(&env, &project(&env), &["add", "."]); + git(&env, &project(&env), &["commit", "-m", "filter fixture"]); + git( + &env, + &project(&env), + &["config", "filter.probe.clean", "sh filter.sh"], + ); + git(&env, &project(&env), &["config", "filter.probe.smudge", "cat"]); + git(&env, &project(&env), &["config", "filter.probe.required", "true"]); + let record = run(&env, vec![ + ScriptTurn::tool("filter", "write", &serde_json::json!({"path":"filter.sh", "content":"printf escaped > \"$HOME/continuation-filter-escape\" 2>/dev/null || true\ncat\n"}).to_string()), + ScriptTurn::tool("payload", "write", r#"{"path":"fixture.data","content":"after\n"}"#), + ScriptTurn::text("done"), + ]); + assert!( + !env.home().join("continuation-filter-escape").exists(), + "{record}" + ); + assert_eq!(record["outcome"], "done", "{record}"); +} + +#[test] +fn large_conflicted_merge_has_a_bounded_worker_handoff() { + let env = TestEnv::new(); + setup(&env, "[]"); + let names: Vec<_> = (0..300) + .map(|i| format!("conflict-{i:03}-{}-file.txt", "x".repeat(80))) + .collect(); + for name in &names { + env.write(&format!("work/project/{name}"), "original\n"); + } + git(&env, &project(&env), &["add", "."]); + git(&env, &project(&env), &["commit", "-m", "many shared paths"]); + git(&env, &project(&env), &["checkout", "-b", "agent/test"]); + for name in &names { + env.write(&format!("work/project/{name}"), "task\n"); + } + git(&env, &project(&env), &["add", "."]); + git(&env, &project(&env), &["commit", "-m", "task versions"]); + git(&env, &project(&env), &["checkout", "main"]); + for name in &names { + env.write(&format!("work/project/{name}"), "base\n"); + } + git(&env, &project(&env), &["add", "."]); + git(&env, &project(&env), &["commit", "-m", "base versions"]); + let (record, requests) = run_observed( + &env, + vec![ScriptTurn::text("blocked")], + &["work", "../tasks.json"], + None, + ); + assert_eq!(record["outcome"], "blocked", "{record}"); + let prompt = requests + .iter() + .flat_map(|r| &r.messages) + .filter_map(|m| m.content.as_deref()) + .find(|text| text.contains("There is a merge in progress")) + .expect("merge handoff reached worker"); + assert!( + prompt.len() <= 16 * 1024, + "merge handoff retained {} bytes", + prompt.len() + ); +} diff --git a/oxa/oxa-work/src/lib.rs b/oxa/oxa-work/src/lib.rs index dc74e7942..76e638467 100644 --- a/oxa/oxa-work/src/lib.rs +++ b/oxa/oxa-work/src/lib.rs @@ -6,6 +6,7 @@ use std::os::unix::fs::{DirBuilderExt, OpenOptionsExt}; use std::path::{Path, PathBuf}; use std::process::{Command, Output, Stdio}; +mod tree; mod worker; pub use worker::{WorkerOutcome, WorkerResult}; @@ -25,7 +26,7 @@ fn default_base() -> String { "main".into() } -#[derive(Clone, Copy, Debug, Serialize, PartialEq, Eq)] +#[derive(Clone, Copy, Debug, Deserialize, Serialize, PartialEq, Eq)] #[serde(rename_all = "snake_case")] pub enum Outcome { Done, @@ -34,7 +35,7 @@ pub enum Outcome { Blocked, } -#[derive(Debug, Serialize)] +#[derive(Debug, Deserialize, Serialize)] pub struct Record { pub id: String, pub branch: String, @@ -227,7 +228,8 @@ pub struct SupervisorRequest { #[derive(Deserialize, Serialize)] #[serde(tag = "kind", rename_all = "snake_case", deny_unknown_fields)] pub enum SupervisorOperation { - Checkout { branch: String }, + Checkout { branch: String, create: bool }, + Merge { base: String }, Checks { commands: Vec }, Inspect, } @@ -316,6 +318,35 @@ fn dirty_worktree( } } +fn worker_and_checks( + worker: &Result, + merge: Result<()>, + checks: Result, +) -> Result { + let mut errors = Vec::new(); + match worker { + Ok(worker) => errors.extend(worker.failure()), + Err(error) => errors.push(format!("worker: {error}")), + } + if let Err(error) = merge { + errors.push(format!("merge verification: {error}")); + } + let failures = match checks { + Ok(failures) => failures, + Err(error) => { + errors.push(error); + String::new() + } + }; + if errors.is_empty() { + return Ok(failures); + } + if !failures.is_empty() { + errors.push(format!("Acceptance checks:\n{failures}")); + } + Err(errors.join("\n")) +} + pub fn blocked_record(task: &Task, detail: String) -> Record { Record { id: task.id.clone(), @@ -365,9 +396,7 @@ pub fn run_task_with_policy( // Keep the inode so a crashed runner leaves no stale ownership and concurrent // runners cannot acquire locks on two different files with the same name. let receipt = storage.join(format!("{}.json", task.id)); - if receipt.exists() { - return Err("task already has a receipt; retained for inspection".into()); - } + let replacing = receipt.exists(); // The common git directory must not be an ancestor of the child cwd: the sandbox // deliberately refuses writable git binds with that layout. let repo_dir = if common.file_name().is_some_and(|name| name == ".git") { @@ -382,6 +411,7 @@ pub fn run_task_with_policy( let trees = parent.join(".oxa-worktrees").join(name); fs::create_dir_all(&trees).map_err(|e| e.to_string())?; let tree = trees.join(&task.id); + tree::check_receipt(&receipt, &tree, task)?; let mut record = Record { id: task.id.clone(), branch: task.branch.clone(), @@ -393,63 +423,21 @@ pub fn run_task_with_policy( base_sha: Some(planned.base_sha.clone()), }; let result = (|| -> Result { - if tree.exists() { - return Err("task worktree already exists; retained for inspection".into()); - } let base = &planned.base_sha; let commands = &planned.commands; - let branch = format!("refs/heads/{}", task.branch); - let exists = output(git(policy, &root, &["show-ref", "--verify", "--quiet", &branch]))?; - match exists.status.code() { - Some(1) => {} - Some(0) => return Err("task branch already exists; retained for inspection".into()), - _ => return Err(String::from_utf8_lossy(&exists.stderr).into_owned()), - } - let tree_arg = tree.to_str().ok_or("non-UTF8 worktree path")?; - // Bootstrap detached metadata without repository callbacks. Even - // --no-checkout runs reference hooks unless they are suppressed here. - // The real task branch and its reference hooks are created in bwrap. - checked(git( - policy, - &root, - &[ - "-c", - "core.hooksPath=/dev/null", - "worktree", - "add", - "--no-checkout", - "--detach", - tree_arg, - base, - ], - ))?; + let prepared = tree::prepare(&root, &tree, task, base, binary, policy, &lock_file)?; let tree = tree.canonicalize().map_err(|e| e.to_string())?; - let checkout = supervise( - binary, - &tree, - SupervisorRequest { - source: root.clone(), - operation: SupervisorOperation::Checkout { - branch: task.branch.clone(), - }, - }, - policy, - &lock_file, - )?; - if !checkout.status.success() { - return Err(format!( - "sandboxed worktree checkout failed: {}", - String::from_utf8_lossy(&checkout.stderr) - )); - } - let initial = checked(git(policy, &tree, &["rev-parse", "HEAD"]))?; - let first = worker::run(binary, &tree, task, &task.prompt, policy, &lock_file, None)?; - record.worker = Some(first.result.clone()); - record.session_id = first.session.clone(); - let failures = acceptance(binary, &tree, &root, commands, policy, &lock_file)?; - if let Some(error) = first.failure() { - return Err(format!("{error}\nAcceptance checks:\n{failures}")); + let first = worker::run(binary, &tree, task, &prepared.prompt, policy, &lock_file, None); + if let Ok(worker) = &first { + record.worker = Some(worker.result.clone()); + record.session_id = worker.session.clone(); } + let failures = worker_and_checks( + &first, + tree::ensure_merged(policy, &tree, base, &task.branch), + acceptance(binary, &tree, &root, commands, policy, &lock_file), + )?; + let first = first?; if !failures.is_empty() { let repair = worker::run( binary, @@ -459,13 +447,16 @@ pub fn run_task_with_policy( policy, &lock_file, first.session.as_deref(), - )?; - record.worker = Some(repair.result.clone()); - record.session_id = repair.session.clone(); - let failures = acceptance(binary, &tree, &root, commands, policy, &lock_file)?; - if let Some(error) = repair.failure() { - return Err(format!("{error}\nAcceptance checks:\n{failures}")); + ); + if let Ok(worker) = &repair { + record.worker = Some(worker.result.clone()); + record.session_id = worker.session.clone(); } + let failures = worker_and_checks( + &repair, + tree::ensure_merged(policy, &tree, base, &task.branch), + acceptance(binary, &tree, &root, commands, policy, &lock_file), + )?; if !failures.is_empty() { record.detail = failures; return Ok(Outcome::Red); @@ -473,7 +464,7 @@ pub fn run_task_with_policy( } let head = checked(git(policy, &tree, &["rev-parse", "HEAD"]))?; let dirty = dirty_worktree(binary, &tree, &root, policy, &lock_file)?; - Ok(if head == initial && !dirty { + Ok(if head == prepared.initial && !dirty { Outcome::NothingToDo } else { Outcome::Done @@ -483,11 +474,11 @@ pub fn run_task_with_policy( Ok(outcome) => record.outcome = outcome, Err(e) => record.detail = e, } - save_receipt(&receipt, &record)?; + save_receipt(&receipt, &record, replacing)?; Ok(record) } -fn save_receipt(path: &Path, record: &Record) -> Result<()> { +fn save_receipt(path: &Path, record: &Record, replacing: bool) -> Result<()> { let nonce = std::time::SystemTime::now() .duration_since(std::time::UNIX_EPOCH) .unwrap_or_default() @@ -503,10 +494,13 @@ fn save_receipt(path: &Path, record: &Record) -> Result<()> { file.write_all(&serde_json::to_vec_pretty(record).map_err(|e| e.to_string())?) .map_err(|e| e.to_string())?; file.sync_all().map_err(|e| e.to_string())?; - // Atomic publication with create-only semantics: an existing receipt - // is never overwritten, even if one appears while the task runs. - fs::hard_link(&temporary, path).map_err(|e| e.to_string())?; - fs::remove_file(&temporary).map_err(|e| e.to_string())?; + if replacing { + // Only the task's already validated receipt is replaced under its lock. + fs::rename(&temporary, path).map_err(|e| e.to_string())?; + } else { + fs::hard_link(&temporary, path).map_err(|e| e.to_string())?; + fs::remove_file(&temporary).map_err(|e| e.to_string())?; + } fs::File::open(path.parent().ok_or("receipt has no parent")?) .and_then(|parent| parent.sync_all()) .map_err(|e| e.to_string()) diff --git a/oxa/oxa-work/src/tree.rs b/oxa/oxa-work/src/tree.rs new file mode 100644 index 000000000..faa47df7d --- /dev/null +++ b/oxa/oxa-work/src/tree.rs @@ -0,0 +1,230 @@ +//! Continue linked worktrees with ordinary sandboxed merges; retain every conflict and edit. +use super::{ + checked, dirty_worktree, git, output, supervise, Result, RunPolicy, SupervisorOperation, + SupervisorRequest, Task, +}; +use std::fs; +use std::path::{Path, PathBuf}; + +pub(crate) struct Prepared { + pub initial: String, + pub prompt: String, +} + +fn git_path(policy: &RunPolicy, tree: &Path, name: &str) -> Result { + checked(git( + policy, + tree, + &["rev-parse", "--path-format=absolute", "--git-path", name], + )) + .map(PathBuf::from) +} + +fn merging(policy: &RunPolicy, tree: &Path) -> Result { + Ok(git_path(policy, tree, "MERGE_HEAD")?.exists()) +} + +fn merge_prompt( + policy: &RunPolicy, + tree: &Path, + task: &Task, + base: &str, + diagnostic: &str, +) -> Result { + // Index-only, no helpers or worktree content conversion. Stat output is + // bounded to twenty paths instead of retaining an unbounded name list. + let paths = checked(git( + policy, + tree, + &[ + "diff", + "--cached", + "--stat", + "--stat-count=20", + "--stat-width=120", + "--stat-name-width=100", + "--no-ext-diff", + "--no-textconv", + "--diff-filter=U", + ], + ))?; + let pending = checked(git(policy, tree, &["rev-parse", "MERGE_HEAD"]))?; + Ok(format!("{}\n\nThere is a merge in progress from base {} at commit {pending}. The current base for this run is {base}. Resolve the conflicts, stage the resolutions, and finish the merge commit before completing the task. Then run `git merge --no-edit {base}` to integrate the captured current base as well, resolving and committing any further conflicts. Preserve the task's existing work.\nConflicted paths (at most twenty; use git diff --name-only --diff-filter=U for the full list):\n{paths}\nMerge output:\n{diagnostic}", task.prompt, task.base)) +} + +pub(crate) fn validate(policy: &RunPolicy, repo: &Path, tree: &Path, task: &Task) -> Result<()> { + let canonical = tree.canonicalize().map_err(|e| e.to_string())?; + if !fs::symlink_metadata(tree.join(".git")).is_ok_and(|m| m.is_file()) + || canonical == repo.canonicalize().map_err(|e| e.to_string())? + { + return Err("retained directory is not a separate linked task worktree".into()); + } + let actual = PathBuf::from(checked(git(policy, tree, &["rev-parse", "--show-toplevel"]))?); + let common = |p: &Path| -> Result { + PathBuf::from(checked(git( + policy, + p, + &["rev-parse", "--path-format=absolute", "--git-common-dir"], + ))?) + .canonicalize() + .map_err(|e| e.to_string()) + }; + if actual.canonicalize().map_err(|e| e.to_string())? != canonical || common(tree)? != common(repo)? { + return Err("retained directory is not this repository's task worktree".into()); + } + if checked(git(policy, tree, &["symbolic-ref", "--quiet", "HEAD"]))? + != format!("refs/heads/{}", task.branch) + { + return Err("retained worktree is on a different branch".into()); + } + Ok(()) +} + +pub(crate) fn prepare( + repo: &Path, + tree: &Path, + task: &Task, + base: &str, + binary: &Path, + policy: &RunPolicy, + lock: &fs::File, +) -> Result { + let retained = tree.exists(); + if !retained { + let branch = format!("refs/heads/{}", task.branch); + let exists = output(git(policy, repo, &["show-ref", "--verify", "--quiet", &branch]))?; + let create = match exists.status.code() { + Some(0) => false, + Some(1) => true, + _ => return Err(String::from_utf8_lossy(&exists.stderr).into()), + }; + let tree_arg = tree.to_str().ok_or("non-UTF8 worktree path")?; + let mut args = vec![ + "-c", + "core.hooksPath=/dev/null", + "worktree", + "add", + "--no-checkout", + ]; + if create { + args.push("--detach"); + } + args.push(tree_arg); + args.push(if create { base } else { &task.branch }); + // Only metadata on the host. Git still refuses a branch checked out + // elsewhere; no task-branch update or checkout callback runs here. + checked(git(policy, repo, &args))?; + let checkout = supervise( + binary, + tree, + SupervisorRequest { + source: repo.to_path_buf(), + operation: SupervisorOperation::Checkout { + branch: task.branch.clone(), + create, + }, + }, + policy, + lock, + )?; + if !checkout.status.success() { + return Err(format!( + "sandboxed worktree checkout failed: {}", + String::from_utf8_lossy(&checkout.stderr) + )); + } + } + validate(policy, repo, tree, task)?; + for operation in ["rebase-merge", "rebase-apply", "CHERRY_PICK_HEAD", "REVERT_HEAD"] { + if git_path(policy, tree, operation)?.exists() { + return Err(format!("retained worktree has {operation} in progress")); + } + } + let initial = checked(git(policy, tree, &["rev-parse", "HEAD"]))?; + if merging(policy, tree)? { + return Ok(Prepared { + initial, + prompt: merge_prompt(policy, tree, task, base, "Resuming the retained merge.")?, + }); + } + if retained && dirty_worktree(binary, tree, repo, policy, lock)? { + return Err("retained worktree has uncommitted changes; commit them before continuing".into()); + } + let merged = supervise( + binary, + tree, + SupervisorRequest { + source: repo.to_path_buf(), + operation: SupervisorOperation::Merge { base: base.into() }, + }, + policy, + lock, + )?; + if !merged.status.success() { + let diagnostic = String::from_utf8_lossy(&merged.stderr); + if merged.status.code() != Some(1) || !merging(policy, tree)? { + return Err(format!("base merge failed: {diagnostic}")); + } + return Ok(Prepared { + initial, + prompt: merge_prompt(policy, tree, task, base, &diagnostic)?, + }); + } + ensure_merged(policy, tree, base, &task.branch)?; + // A clean base-only merge is preparation, not new worker work. + Ok(Prepared { + initial: checked(git(policy, tree, &["rev-parse", "HEAD"]))?, + prompt: task.prompt.clone(), + }) +} + +pub(crate) fn ensure_merged(policy: &RunPolicy, tree: &Path, base: &str, branch: &str) -> Result<()> { + if checked(git(policy, tree, &["symbolic-ref", "--quiet", "HEAD"]))? != format!("refs/heads/{branch}") { + return Err("agent left the worktree on a different branch".into()); + } + let unmerged = output(git( + policy, + tree, + &[ + "diff", + "--cached", + "--quiet", + "--no-ext-diff", + "--no-textconv", + "--diff-filter=U", + ], + ))?; + match unmerged.status.code() { + Some(0) => {} + Some(1) => return Err("merge remains in progress; retained for resolution".into()), + _ => { + return Err(format!( + "cannot inspect merge index: {}", + String::from_utf8_lossy(&unmerged.stderr) + )) + } + } + if merging(policy, tree)? { + return Err("merge remains in progress; retained for resolution".into()); + } + let ancestor = output(git(policy, tree, &["merge-base", "--is-ancestor", base, "HEAD"]))?; + match ancestor.status.code() { + Some(0) => Ok(()), + Some(1) => Err("base is not merged into the task branch; retained for continuation".into()), + _ => Err(format!( + "cannot verify captured base: {}", + String::from_utf8_lossy(&ancestor.stderr) + )), + } +} + +pub(crate) fn check_receipt(receipt: &Path, tree: &Path, task: &Task) -> Result<()> { + if receipt.exists() { + let record: super::Record = serde_json::from_slice(&fs::read(receipt).map_err(|e| e.to_string())?) + .map_err(|e| format!("retained receipt: {e}"))?; + if record.id != task.id || record.branch != task.branch || record.worktree != tree { + return Err("retained receipt belongs to a different task branch or worktree".into()); + } + } + Ok(()) +}