fix(add): stop prepending above the H1 when the Tasks section is empty

`lash add` against an existing file whose `## Tasks` section held no
tasks wrote the checkbox at line 1, above the H1. The parser never saw it
as a task, so `lash index` reported 0 tasks and `lash lint` passed clean:
the task was on disk and nowhere else, with exit code 0 and a normal
success message pointing at `path:0`.

`resolve_append` returned `line_number: 0` whenever the file had no
tasks, commented "Signal for new file", and the emitter mapped 0 to
insert index 0. The sentinel conflated "brand-new file" with "existing
file whose Tasks section is empty", and only the first is safe to write
at offset 0.

`PlacementInfo` now carries an `InsertAnchor` instead of a bare line
number: either a concrete `Line(n)` or `EndOfTasksSection`. The ambiguity
cannot recur, because there is no longer a number that means something
other than a line.

Resolving `EndOfTasksSection` needs the source text. A parsed `TaskFile`
records task line numbers and nothing about section boundaries, so an
empty section has nothing to anchor to, which is why the old code fell
back to a hardcoded guess of line 15. The emitter resolves it instead,
against the content it already reads, via a new
`parser::header::tasks_section_body`. That returns the section's line
span using pulldown-cmark, so a `##` inside a code fence does not close
the section, and H3 headings stay inside it (files group tasks under
`### Subsection` headings). With no `## Tasks` heading at all it appends
at end of file rather than guessing.

The line reported on success now comes from where the task was actually
written, for new files as well, so `path:0` is gone.

Two things fixed in passing, both in code this commit rewrites:
`find_end_of_tasks_section` and its line-15 estimate are deleted rather
than ported, and `insert_into_existing` restores the trailing newline
that `join` dropped, which had every `lash add` leaving the file ending
mid-line.

Tests: five integration tests in add_command_test.rs (empty section lands
below the header and reports the right line, is indexed afterwards, a
following `## Notes` section survives intact, the new-file path still
writes a well-formed file, and files end in a newline) plus six unit
tests on anchor resolution covering empty sections, trailing blank lines,
a heading inside a code fence, a file with no Tasks section, and
clamping. Four of the five integration tests fail without the fix.

Author: fohara

crates/lash-cli/tests/add_command_test.rs

@@ -366,3 +366,194 @@ fn test_add_preserves_multiline_agent_note_through_reindex() {
         );
     }
 }
+
+// ---------------------------------------------------------------------
+// Appending to a file whose `## Tasks` section is empty
+//
+// `resolve_append` used to return the magic line number 0 whenever the
+// target file held no tasks, meaning "this is a brand-new file, write at
+// offset 0". For a file that already existed with an empty `## Tasks`
+// section that was catastrophically wrong: the checkbox was prepended
+// above the H1, so the parser never saw it as a task, `lash index` found
+// nothing, and `lash lint` still passed. The task was on disk and
+// invisible.
+// ---------------------------------------------------------------------
+
+/// Line the task line lands on, 1-indexed.
+fn task_line_number(content: &str, needle: &str) -> usize {
+    content
+        .lines()
+        .position(|line| line.contains(needle))
+        .map(|idx| idx + 1)
+        .unwrap_or_else(|| panic!("'{needle}' not found in:\n{content}"))
+}
+
+/// Run `lash add`, returning the command's stdout.
+fn add_task(project: &TestProject, title: &str, file: &str) -> String {
+    let output = run_lash_command()
+        .arg("--root")
+        .arg(project.path())
+        .arg("add")
+        .arg(title)
+        .arg("--file")
+        .arg(file)
+        .assert()
+        .success()
+        .get_output()
+        .stdout
+        .clone();
+    String::from_utf8(output).unwrap()
+}
+
+#[test]
+fn test_add_to_empty_tasks_section_lands_below_the_header() {
+    let project = TestProject::builder()
+        .with_index("test-project", "Test Project")
+        .with_file(
+            "empty.md",
+            r#"# Empty
+
+@id: empty
+
+## Tasks
+"#,
+        )
+        .build();
+    index(&project);
+
+    let stdout = add_task(&project, "Ship it", "empty.md");
+
+    let content = fs::read_to_string(project.file_path("empty.md")).unwrap();
+
+    assert_eq!(
+        content.lines().next(),
+        Some("# Empty"),
+        "the H1 must still be the first line:\n{content}"
+    );
+    // The old sentinel surfaced here too, as a literal `empty.md:0`.
+    assert!(
+        stdout.contains(&format!(
+            "empty.md:{}",
+            task_line_number(&content, "- [ ] Ship it")
+        )),
+        "reported line does not match where the task was written:\n{stdout}"
+    );
+    assert!(
+        task_line_number(&content, "- [ ] Ship it") > task_line_number(&content, "## Tasks"),
+        "task must land inside the Tasks section:\n{content}"
+    );
+}
+
+#[test]
+fn test_add_to_empty_tasks_section_is_indexed() {
+    // The destructive part of the bug: the task was written to a place the
+    // parser does not read, so it existed on disk and nowhere else.
+    let project = TestProject::builder()
+        .with_index("test-project", "Test Project")
+        .with_file(
+            "empty.md",
+            r#"# Empty
+
+@id: empty
+
+## Tasks
+"#,
+        )
+        .build();
+    index(&project);
+
+    add_task(&project, "Ship it", "empty.md");
+    index(&project);
+
+    run_lash_command()
+        .arg("--root")
+        .arg(project.path())
+        .arg("list")
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("Ship it"));
+}
+
+#[test]
+fn test_add_to_empty_tasks_section_keeps_following_sections_intact() {
+    let project = TestProject::builder()
+        .with_index("test-project", "Test Project")
+        .with_file(
+            "sections.md",
+            r#"# Sections
+
+@id: sections
+
+## Tasks
+
+## Notes
+
+Prose that must survive.
+"#,
+        )
+        .build();
+    index(&project);
+
+    add_task(&project, "Ship it", "sections.md");
+
+    let content = fs::read_to_string(project.file_path("sections.md")).unwrap();
+
+    assert_eq!(
+        content.lines().next(),
+        Some("# Sections"),
+        "the H1 must still be the first line:\n{content}"
+    );
+    assert!(
+        content.contains("Prose that must survive."),
+        "trailing section content was destroyed:\n{content}"
+    );
+
+    let task = task_line_number(&content, "- [ ] Ship it");
+    assert!(
+        task > task_line_number(&content, "## Tasks")
+            && task < task_line_number(&content, "## Notes"),
+        "task escaped the Tasks section:\n{content}"
+    );
+}
+
+#[test]
+fn test_add_creating_a_new_file_still_writes_a_well_formed_file() {
+    // Guards the other half of the split: the old code used one sentinel for
+    // both "new file" and "existing file with an empty section".
+    let project = TestProject::builder()
+        .with_index("test-project", "Test Project")
+        .build();
+    index(&project);
+
+    add_task(&project, "Ship it", "fresh.md");
+
+    let content = fs::read_to_string(project.file_path("fresh.md")).unwrap();
+
+    assert!(
+        task_line_number(&content, "- [ ] Ship it") > task_line_number(&content, "## Tasks"),
+        "task must land inside the Tasks section:\n{content}"
+    );
+
+    index(&project);
+    run_lash_command()
+        .arg("--root")
+        .arg(project.path())
+        .arg("list")
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("Ship it"));
+}
+
+#[test]
+fn test_add_leaves_the_file_ending_in_a_newline() {
+    let project = project_with_tasks_file();
+    index(&project);
+
+    add_task(&project, "Second task", "tasks.md");
+
+    let content = fs::read_to_string(project.file_path("tasks.md")).unwrap();
+    assert!(
+        content.ends_with('\n'),
+        "file ends mid-line, every later diff shows '\\ No newline at end of file':\n{content}"
+    );
+}