Add regression test coverage for merged PRs #13-#20

Adds targeted regression tests for each bug fix and behavioral guarantee
introduced across the eight feature PRs. Total: 205 → 254 tests (+49).

- background-tasks: 0 → 11 tests. Cover get()-evicts-on-read,
  truncation-by-chars on Completed/Failed, running tasks NOT evicted,
  shared state across clones (Arc<Mutex>), no-op on missing.
- apply-patch: 8 → 16 tests. Multi-op stop-on-failure with prior ops
  staying applied, ambiguous-update rejection, 1MB create cap (incl.
  off-by-one), nested-dir creation, PatchOp deserialization.
- glob-tool: 5 → 11 tests. Real-FS integration via TempTree: walks
  files, empty result returns empty string (not 'no files matched'),
  mtime sort with explicit path != CWD, respects .gitignore, regex
  metachars escaped, * doesn't cross directory boundaries.
- plan-tools: 5 → 8 tests. Source-level regression test that plan_exit
  has no fs::write / PLAN.md side-effects, channel-unavailable +
  reply-dropped error paths.
- web-tools: 7 → 12 / 4 → 7 tests. Wrap-width regression (long
  paragraph must wrap), input validation (empty/too many URLs),
  partial-field formatting in search results, 500-char snippet cap.
- task-status: 6 → 9 tests. Completed task evicts after one read,
  wait=true returns on Failed, wait=true on missing errors promptly
  (bounded timeout guard against infinite-loop regression).
- question-tool: 5 → 10 tests. Header → markdown ## heading, channel +
  reply error paths, default custom=true, multi-select comma-join.
- agent-reminders: 0 → 5 tests. Extracted append_mode_reminder() pure
  fn so the reminder injection is unit-testable. Covers plan/review/
  code modes, PLAN.md gate on code mode, unknown prompts pass through
  unchanged, section-separator prefix.

Each regression test has a comment explaining the bug it guards
against.

Author: Yogthos

src/agent/builder.rs

@@ -109,25 +109,11 @@ pub async fn build_agent_inner<M: CompletionModel + 'static>(
 
     // Inject mode-specific reminders
     if let Some(prompt_name) = &context.current_prompt_name {
-        match prompt_name.as_str() {
-            "plan" => {
-                preamble.push_str("\n\n---\n\nYou are now in PLAN mode. Create a detailed implementation plan. Save it to PLAN.md in the current directory. Analyze the task, break it into concrete steps, consider edge cases and trade-offs. Do NOT write any code or run any commands until the user reviews and approves the plan.");
-            }
-            "review" | "review-security" => {
-                preamble.push_str("\n\n---\n\nYou are now in REVIEW mode. Review the code or plan carefully. Identify bugs, security issues, performance problems, and design flaws. Be thorough and specific. Provide actionable feedback.");
-            }
-            "code" => {
-                let plan_path = std::env::current_dir()
-                    .unwrap_or_else(|_| ".".into())
-                    .join("PLAN.md");
-                if plan_path.exists() {
-                    preamble.push_str(
-                        "\n\n---\n\nA plan file exists at PLAN.md. Execute the plan step by step. Write and test code following the plan. Report progress after each step. The plan is your guide — follow it closely."
-                    );
-                }
-            }
-            _ => {}
-        }
+        let plan_exists = std::env::current_dir()
+            .unwrap_or_else(|_| ".".into())
+            .join("PLAN.md")
+            .exists();
+        append_mode_reminder(&mut preamble, prompt_name, plan_exists);
     }
 
     let mut builder = AgentBuilder::new(model).preamble(&preamble);
@@ -314,3 +300,80 @@ pub fn create_client(api_key: Option<&str>) -> anyhow::Result<openrouter::Client
         })?;
     Ok(openrouter::Client::new(String::from(key))?)
 }
+
+/// Append a mode-specific reminder to `preamble` based on the active prompt
+/// name. `plan_exists` reports whether `PLAN.md` is present in CWD — only
+/// consulted for the `code` mode reminder. Unknown prompt names produce no
+/// reminder so custom prompts don't accidentally pick up plan/review semantics.
+pub(crate) fn append_mode_reminder(preamble: &mut String, prompt_name: &str, plan_exists: bool) {
+    match prompt_name {
+        "plan" => {
+            preamble.push_str("\n\n---\n\nYou are now in PLAN mode. Create a detailed implementation plan. Save it to PLAN.md in the current directory. Analyze the task, break it into concrete steps, consider edge cases and trade-offs. Do NOT write any code or run any commands until the user reviews and approves the plan.");
+        }
+        "review" | "review-security" => {
+            preamble.push_str("\n\n---\n\nYou are now in REVIEW mode. Review the code or plan carefully. Identify bugs, security issues, performance problems, and design flaws. Be thorough and specific. Provide actionable feedback.");
+        }
+        "code" if plan_exists => {
+            preamble.push_str(
+                "\n\n---\n\nA plan file exists at PLAN.md. Execute the plan step by step. Write and test code following the plan. Report progress after each step. The plan is your guide — follow it closely.",
+            );
+        }
+        _ => {}
+    }
+}
+
+#[cfg(test)]
+mod reminder_tests {
+    use super::append_mode_reminder;
+
+    #[test]
+    fn plan_mode_injects_plan_reminder() {
+        let mut p = String::from("base");
+        append_mode_reminder(&mut p, "plan", false);
+        assert!(p.contains("PLAN mode"));
+        assert!(p.contains("PLAN.md"));
+        assert!(p.contains("Do NOT write any code"));
+    }
+
+    #[test]
+    fn review_modes_inject_review_reminder() {
+        for mode in &["review", "review-security"] {
+            let mut p = String::from("base");
+            append_mode_reminder(&mut p, mode, false);
+            assert!(p.contains("REVIEW mode"), "mode={mode}");
+            assert!(p.contains("Identify bugs"), "mode={mode}");
+        }
+    }
+
+    // Regression: the `code` reminder must only appear when PLAN.md exists.
+    // Without that guard every code-mode session would have a stale "execute
+    // the plan" instruction even with no plan written.
+    #[test]
+    fn regression_code_mode_reminder_requires_plan_md() {
+        let mut p_with = String::from("base");
+        append_mode_reminder(&mut p_with, "code", true);
+        assert!(p_with.contains("plan file exists"));
+
+        let mut p_without = String::from("base");
+        append_mode_reminder(&mut p_without, "code", false);
+        assert_eq!(p_without, "base", "no reminder must be added");
+    }
+
+    // Unknown prompts (custom user prompts) must produce no reminder so the
+    // plan/review semantics don't bleed into other modes.
+    #[test]
+    fn unknown_prompt_name_appends_nothing() {
+        let mut p = String::from("base");
+        append_mode_reminder(&mut p, "my-custom-prompt", true);
+        assert_eq!(p, "base");
+    }
+
+    // Each reminder is prefixed by the section separator so it visually
+    // detaches from the prior prompt — regression-guards the leading "\n\n---".
+    #[test]
+    fn reminders_use_section_separator() {
+        let mut p = String::new();
+        append_mode_reminder(&mut p, "plan", false);
+        assert!(p.starts_with("\n\n---\n\n"), "got: {p:?}");
+    }
+}

src/agent/tools/apply_patch.rs

@@ -294,4 +294,221 @@ mod tests {
         let def = tool.definition(String::new()).await;
         assert_eq!(def.name, "apply_patch");
     }
+
+    // Regression: update is documented as text-find-and-replace and must reject
+    // ambiguous matches rather than silently replacing the first one. Without
+    // this guard the agent could clobber wrong code in a file with repeated
+    // boilerplate (use statements, similar function bodies, etc.).
+    #[test]
+    fn regression_update_rejects_multiple_matches() {
+        let tf = TestFile::new("update-ambiguous.txt");
+        std::fs::write(&tf.path, "foo bar foo baz foo").unwrap();
+        let result = apply_update(&tf.path, "foo", "qux");
+        assert!(result.is_err());
+        let msg = result.unwrap_err();
+        assert!(msg.contains("3 locations"), "got: {msg}");
+        // File should be untouched.
+        assert_eq!(
+            std::fs::read_to_string(&tf.path).unwrap(),
+            "foo bar foo baz foo"
+        );
+    }
+
+    // Regression: prior to the fix, multi-op patches were documented as
+    // "atomic" but in fact left earlier successful ops applied when a later op
+    // failed. We now stop on first failure AND the prior ops MUST stay applied
+    // (no rollback). The error report must explicitly call out which op failed
+    // and ops after the failure must NOT execute.
+    #[tokio::test]
+    async fn regression_multi_op_stops_on_failure_prior_ops_remain() {
+        let a = TestFile::new("multi-op-a.txt");
+        let b_existing = TestFile::new("multi-op-b.txt");
+        let c_should_not_exist = TestFile::new("multi-op-c.txt");
+
+        // Pre-create B so the second op (create B) fails.
+        std::fs::write(&b_existing.path, "already here").unwrap();
+
+        let tool = ApplyPatchTool::new(None, None);
+        let result = tool
+            .call(ApplyPatchArgs {
+                operations: vec![
+                    PatchOp::Create {
+                        path: a.path.clone(),
+                        content: "A content".into(),
+                    },
+                    PatchOp::Create {
+                        path: b_existing.path.clone(),
+                        content: "B content".into(),
+                    },
+                    PatchOp::Create {
+                        path: c_should_not_exist.path.clone(),
+                        content: "C content".into(),
+                    },
+                ],
+            })
+            .await
+            .unwrap();
+
+        // A was created.
+        assert!(Path::new(&a.path).exists(), "A must remain applied");
+        assert_eq!(std::fs::read_to_string(&a.path).unwrap(), "A content");
+        // B was not overwritten.
+        assert_eq!(
+            std::fs::read_to_string(&b_existing.path).unwrap(),
+            "already here"
+        );
+        // C was never attempted.
+        assert!(
+            !Path::new(&c_should_not_exist.path).exists(),
+            "C must not run after failure"
+        );
+        // Report names both the success and the failure.
+        assert!(result.contains("created"), "got: {result}");
+        assert!(result.contains("FAILED"), "got: {result}");
+    }
+
+    // Regression: create previously had no size cap; the agent could write
+    // multi-GB files by accident. 1MB limit must be enforced before touching
+    // the filesystem, and the operation must not produce a partial write.
+    #[tokio::test]
+    async fn regression_create_rejects_oversized_content() {
+        let tf = TestFile::new("oversize.txt");
+        let too_big = "x".repeat(1_048_577); // 1MB + 1 byte
+
+        let tool = ApplyPatchTool::new(None, None);
+        let result = tool
+            .call(ApplyPatchArgs {
+                operations: vec![PatchOp::Create {
+                    path: tf.path.clone(),
+                    content: too_big,
+                }],
+            })
+            .await
+            .unwrap();
+
+        assert!(result.contains("FAILED"), "got: {result}");
+        assert!(result.contains("exceeds"), "got: {result}");
+        assert!(
+            !Path::new(&tf.path).exists(),
+            "no file should exist after size-limit rejection"
+        );
+    }
+
+    // Right at the limit must succeed; off-by-one boundary check.
+    #[tokio::test]
+    async fn create_accepts_content_at_size_limit() {
+        let tf = TestFile::new("at-limit.txt");
+        let at_limit = "x".repeat(1_048_576); // exactly 1MB
+
+        let tool = ApplyPatchTool::new(None, None);
+        let result = tool
+            .call(ApplyPatchArgs {
+                operations: vec![PatchOp::Create {
+                    path: tf.path.clone(),
+                    content: at_limit,
+                }],
+            })
+            .await
+            .unwrap();
+
+        assert!(!result.contains("FAILED"), "got: {result}");
+        assert!(Path::new(&tf.path).exists());
+        assert_eq!(std::fs::metadata(&tf.path).unwrap().len(), 1_048_576);
+    }
+
+    // create_dir_all is called on the parent — confirms nested-path creates work.
+    #[test]
+    fn create_creates_parent_dirs() {
+        let dir = std::env::temp_dir().join(format!("dirge-test-nested-{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&dir);
+        let nested = dir.join("a/b/c/file.txt");
+        let path_str = nested.to_str().unwrap();
+
+        let result = apply_create(path_str, "deep content");
+        assert!(result.is_ok());
+        assert_eq!(std::fs::read_to_string(&nested).unwrap(), "deep content");
+
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+
+    #[test]
+    fn delete_missing_file_returns_err() {
+        let path = format!("/tmp/dirge-test-delete-ghost-{}.txt", std::process::id());
+        let _ = std::fs::remove_file(&path);
+        let result = apply_delete(&path);
+        assert!(result.is_err());
+    }
+
+    // Multi-op happy path: create + update + rename + delete in sequence,
+    // touching different files. Regression-tests that the loop applies each op
+    // in declaration order and the report lists each.
+    #[tokio::test]
+    async fn multi_op_happy_path_executes_in_order() {
+        let a = TestFile::new("multi-happy-a.txt");
+        let b = TestFile::new("multi-happy-b.txt");
+        let renamed = format!(
+            "/tmp/dirge-test-multi-happy-renamed-{}.txt",
+            std::process::id()
+        );
+        let _ = std::fs::remove_file(&renamed);
+
+        let tool = ApplyPatchTool::new(None, None);
+        let result = tool
+            .call(ApplyPatchArgs {
+                operations: vec![
+                    PatchOp::Create {
+                        path: a.path.clone(),
+                        content: "hello".into(),
+                    },
+                    PatchOp::Update {
+                        path: a.path.clone(),
+                        old_text: "hello".into(),
+                        new_text: "HELLO".into(),
+                    },
+                    PatchOp::Create {
+                        path: b.path.clone(),
+                        content: "scratch".into(),
+                    },
+                    PatchOp::Rename {
+                        path: a.path.clone(),
+                        new_path: renamed.clone(),
+                    },
+                    PatchOp::Delete {
+                        path: b.path.clone(),
+                    },
+                ],
+            })
+            .await
+            .unwrap();
+
+        assert!(!result.contains("FAILED"), "got: {result}");
+        assert!(!Path::new(&a.path).exists()); // renamed away
+        assert!(!Path::new(&b.path).exists()); // deleted
+        assert_eq!(std::fs::read_to_string(&renamed).unwrap(), "HELLO");
+        let _ = std::fs::remove_file(&renamed);
+
+        // Each successful op contributes a line to the report.
+        assert_eq!(
+            result.lines().filter(|l| !l.is_empty()).count(),
+            5,
+            "report: {result}"
+        );
+    }
+
+    // Regression: PatchOp deserializes via internally-tagged `action` enum.
+    // Schema mismatch (e.g. missing `content` for create) must fail at deserialize.
+    #[test]
+    fn patch_op_deserializes_each_variant() {
+        let json = serde_json::json!([
+            {"action": "create", "path": "/tmp/x", "content": "hi"},
+            {"action": "update", "path": "/tmp/x", "old_text": "a", "new_text": "b"},
+            {"action": "delete", "path": "/tmp/x"},
+            {"action": "rename", "path": "/tmp/x", "new_path": "/tmp/y"},
+        ]);
+        let ops: Vec<PatchOp> = serde_json::from_value(json).unwrap();
+        assert!(matches!(ops[0], PatchOp::Create { .. }));
+        assert!(matches!(ops[1], PatchOp::Update { .. }));
+        assert!(matches!(ops[2], PatchOp::Delete { .. }));
+        assert!(matches!(ops[3], PatchOp::Rename { .. }));
+    }
 }