docs(lanes): settle this repo's lane-artifact root at docs/lanes/ (aof)

[Brian Krabach (bkrabach)]

The problem

Every lane working in this repo has been graded against a rule its own goal contradicts.

source of truth	says
the CODE lane goal template (a lane's authoritative spec, read first)	docs/lanes/<lane>/DONE-NOTE.md
check_lane_artifact_paths.py (artifact-path/v1), rule [R2 ai_working/]	ai_working/<lane>/

Both have precedent at origin/main, so it cannot be settled by looking at the repo. Flagged by lane 2nz while landing #299 (35ab604) and confirmed by the manager as item model_performance-aof.

The cost is not tidiness. A checker that disagrees with the spec trains lanes to ignore the checker — and the same checker catches the real hazard, a repo-root DONE-NOTE.md silently clobbering the previous lane's (item kez). 2nz paid the churn twice: it wrote its note to ai_working/ on the checker's say-so, then deleted it and rewrote it under docs/lanes/ (c80e04e).

The decision: option (a) — the goal template wins

(b) is not the cheap option it looks like. The two sides are not independent: tools/rewrite_goal_artifact_paths.py:49 imports resolve_artifact_dir from the checker and generates each goal's ARTIFACT ROOT sentence from it — deliberately, "so the instruction and the check can never disagree". Under (b) you would still have to change the resolver (so the generator emits ai_working/) and change the hand-written CODE goal template, which lives in the manager's per-batch goals/ directory: outside any git repo, with no test harness. The deliverable that stops the recurrence is a test, and under (b) it has nowhere to live.

Two facts then decide which answer is right:

1. R2 fires here only because a lane artifact created the directory. The first tracked path under ai_working/ is ai_working/3yc-timedout-session-resumable/DONE-NOTE.md (0d93352). At 35ab604, all five tracked paths under ai_working/ are lane artifacts; the repo tracks no content there at any ref, and .gitignore mentions only ai_working/tmp. The rule was reading its own past output back as a repo convention.
2. This repo's recent merged history says docs/lanes/ — n1i (fix(resume): narrow the credential refresh to secrets, and thread model_role/provider_preferences through delegate resume #292), 9w0 (feat(spawner): expose a timed-out sub-session's partial output via session.partial (k64 prereq 2/2, PRODUCER) #297), eem (fix(spawner): recover a timed-out delegate's thinking/tool_call work, not only its text #298), 2nz (fix(skills/ten-lane-highway): ship the two sweep guards a tool update kept reverting #299), four consecutive lanes, every one graded VIOLATION today.

What changed

Evaluation repo — branch lane/aof-artifact-path-conflict, commit 449ed59, base 6269c44. That repo has no remote, so the complete patch is committed here as docs/lanes/aof-artifact-path-conflict/PROPOSED-evals-artifact-path-R-PIN.patch.

A new R-PIN rule, checked before R0–R3:

PINNED_ARTIFACT_ROOTS: dict[str, tuple[str, tuple[str, ...]]] = {
    "amplifier-app-cli": ("docs/lanes", ("ai_working",)),
}

Keyed on the checkout directory name and the origin URL slug, so a checkout cloned under another name still pins. legacy_roots is retrospective only — dir_for() never returns one, so no new lane is sent to ai_working/, while lanes that already landed there stay COMPLIANT and stay put.

This repo — docs/lanes/README.md (the same statement for a human reader) plus this lane's own record. No source changed.

Fail-before / pass-after

This real lane, same command, same directory, two checkers (evidence/07-this-lane-graded.txt):

PARENT  (evals main 6269c44)   VIOLATION   expected ai_working/aof-artifact-path-conflict/  [R2 ai_working/]
                                 stray-in-repo  docs/lanes/aof-artifact-path-conflict/DONE-NOTE.md   (+11 more)
                                 --strict exit: 1

PATCHED (lane/aof 449ed59)     COMPLIANT   expected docs/lanes/aof-artifact-path-conflict/  [R-PIN docs/lanes/ (declared for amplifier-app-cli)]
                                 ok             docs/lanes/aof-artifact-path-conflict/DONE-NOTE.md   (+11 more)
                                 --strict exit: 0

Synthetic control, one script pointed at each checker (evidence/01, evidence/02):

RESOLVED     ai_working/<lane>/   [R2 ai_working/]                 ->  docs/lanes/<lane>/   [R-PIN ...]
GOAL-PATH    docs/lanes/<lane>/DONE-NOTE.md -> VIOLATION           ->  COMPLIANT
LEGACY-PATH  ai_working/<lane>/DONE-NOTE.md -> COMPLIANT           ->  COMPLIANT   (unchanged: nothing is relocated)

Both sides agree — at the generator, not just the checker

rewrite_goal_artifact_paths.artifact_dir_for() is the function that writes the ARTIFACT ROOT sentence into a goal file. For all 8 app-cli lanes in the manifest it returned ai_working/<lane>/ before and returns docs/lanes/<lane>/ after (evidence/04). The instruction a future lane is given and the rule it is graded against are now the same string, from the same call.

Batch-wide effect: only this repo moves

--manifest <HW>/manifest.tsv --all --markdown, before vs after (evidence/03):

	COMPLIANT	VIOLATION
whole batch, before	58	56
whole batch, after	62	52
amplifier-app-cli, before	0	7
amplifier-app-cli, after	4	3

The diff contains no other repo — every other repo's rule, expected shape and per-lane status are byte-identical. Pinned by test_unpinned_repo_still_infers_from_the_tree.

The 3 residual violations are pre-existing and unrelated to the root choice: adq wrote ../DONE-NOTE.md outside the checkout (the kez shape, correctly still refused); 9kk wrote into adq's directory; 3yc's manifest lane id differs from its directory name (...-not-resumable vs ...-resumable).

Tests

scenarios/_harness/tests/test_artifact_path_resolution.py, 10 tests, evals suite 233 → 243 passed:

• test_pin_survives_every_directory_that_would_have_moved_it — the recurrence-stopper. probes/ (R1), ai_working/ (R2) and a three-member w9- wave family (R0) all tracked at the base ref simultaneously — every inference the rule can make, each of which alone used to decide the answer — and the answer does not move.
• test_root_done_note_is_still_a_violation + test_root_done_note_is_a_violation_in_an_unpinned_repo_too — kez's hazard, pinned repo and unpinned repo alike. A fix that relaxed this to end the disagreement would have been strictly worse than the disagreement.
• test_a_landed_legacy_note_stays_compliant / test_a_new_lane_is_never_told_the_legacy_root — landed artifacts under both conventions stay exactly where they are; only what a new lane is told changes.
• test_unpinned_repo_still_infers_from_the_tree — R0–R3 unchanged for every repo outside the table.
• test_pin_follows_the_origin_slug_when_the_checkout_is_renamed, test_the_pin_table_is_well_formed, test_a_goal_conformant_note_is_compliant, test_pinned_repo_resolves_to_the_declared_root.

Full suite (this repo)

$ uv run pytest -q
1682 passed, 1 skipped, 13 deselected, 1 xfailed

Byte-identical to the 35ab604 baseline — this lane changes no app-cli source (evidence/06).

Spend

$0.00 against a $0.00 authority (0 runs × 0 arms × $0 / 1.00 = $0.00). No API calls, no DTU, no infrastructure created or claimed. The cap never bound.

Deviation and honest limits

• The lane was launched with an amplifier-app-cli worktree, but both candidate fixes live in the evaluation repo. Writing only a note here would have left the conflict in place, so the change was made where it lives, on a lane branch in a git worktree, exactly as every evals lane in this batch does. Nothing was merged; that repo has no remote, hence the patch artifact.
• The pin is a list, and a list must be maintained. R0–R3 still guess for every repo not in it. That is the trade the item asked for: the defect was that the answer was inferred, and an inference cannot be made to hold still.
• PRE-RULE can no longer fire for a pinned repo (it triggers on expected_now != expected, which a pin makes equal at every ref). legacy_roots covers the same ground here, but a future pin added without one would retroactively fail lanes that obeyed the old answer. The docstring says so at the table.
• docs/lanes/README.md is repo content this lane was not chartered to write. It exists so the decision is legible to a human who never runs the checker. Drop it if you disagree; nothing depends on it.

Full reasoning, deliverable-by-deliverable: docs/lanes/aof-artifact-path-conflict/DONE-NOTE.md.