[agent] Filed by the scheduled architecture audit routine (CLI and core). Register: discussion #560 register.

Question: should .socket/apply.lock keep its v5.0 "never outlives the command" lifecycle, which costs about 200 of the 553 production lines in patch/apply_lock.rs, or should the lock live somewhere it never has to be deleted?

Options:

• A. Keep a persistent lock file in the project. acquire becomes create-if-missing → try_lock_exclusive → backoff; release is closing the handle. The identity check, the vanished and delete-pending retry streaks, the unlink-under-lock, the .socket/ prune and their Windows grace period all go. Cost: a run that persists nothing still leaves .socket/apply.lock (and a .socket/), so users need a .gitignore line or socket-patch writes .socket/.gitignore. This reverses the "nothing to .gitignore" promise in the contract's Lock lifecycle (v5.0) paragraph.
• B. Lock a file outside the project. Lock <user cache dir>/socket-patch/locks/<sha256 of the canonical .socket path>.lock, which is never deleted. The project stays residue-free and the deletion machinery goes, as in A. Cost: two containers sharing one project volume but not one cache directory would no longer serialize, and canonicalization has to be right on case-insensitive and symlinked paths.
• C. No change. Keep the transient file and its machinery; only the layering refactor below proceeds.

Whichever option is chosen, the lock primitive should stop doing vendored crash recovery (see "Layering" below); that part changes no behavior.

Kind: decision. Source: review Part 7.4 (apply.lock); register row C26.

Problem

patch/apply_lock.rs is 553 production lines (1,157 with tests) for an advisory lock. Much of it exists only because the guard deletes the lock file on exit:

• Drop unlinks apply.lock while still holding it, gated on an inode-identity probe, then prunes an empty .socket/;
• because a releaser can unlink between a waiter's open and lock, every attempt re-checks same_file::Handle identity, and the acquire loop keeps two extra retry streaks (Vanished, bounded by VANISHED_LIMIT = 256, and Windows DeletePending, with a 2 s grace floor);
• open_failure classifies macOS EINVAL and a missing parent as "a releaser's cleanup racing us".

The contract makes the lifecycle a v5.0 guarantee (introduced by #247), so changing it is a decision.

Layering (independent of the decision)

Taking the lock also does vendored-mode work:

• acquire replays an interrupted vendored group commit (recover_group_commit) for every lock-taking command, agent-mode apply included;
• the guard's Drop runs the vendored artifact durability barrier.

So patch::apply_lock (agent-mode infrastructure) depends on utils::group_commit and utils::durability, and the commands that read vendored state without the lock (list, vex, vendor --check) never get the replay. A ProjectSession::open(socket_dir) (lock + recover, with the barrier on close) would make the pairing explicit and leave the lock a plain primitive.

Symptoms: none filed. Impact: about 200 production lines (comments included) and their race tests (waiter_does_not_lock_orphaned_inode_after_holder_release, orphaned_inode_holder_does_not_block_the_path, orphan_drop_leaves_the_live_holders_replacement_file_alone, the delete-pending classifier) exist only for the transient file.

Proposed change

• A or B: delete the identity check, Attempt::Vanished/DeletePending, VANISHED_LIMIT, DELETE_PENDING_GRACE, open_failure's cleanup-race arms, the unlink in Drop and prune_empty_socket_dir, plus the race tests above; rewrite the contract's Lock lifecycle paragraph and the --dry-run row.
• C: none here.
• All options: move recover_group_commit and the durability barrier out of apply_lock into one project-session type the CLI's lock_cli wrappers call.

Size and scope

patch/apply_lock.rs (about −200 production lines for A/B), commands/lock_cli.rs (docs only), CLI_CONTRACT.md. The layering move is ~80 lines, mechanical. Out of scope: which commands take the lock.

Acceptance criteria

• A maintainer picks A, B or C on this issue.
• For A/B: apply_lock.rs has no inode-identity check and no vanished/delete-pending retry; concurrent_acquire_release_never_double_holds_and_leaves_no_residue is rewritten to assert no double hold.
• For A: .socket/apply.lock is ignored by git in a fresh project (a test runs git status --porcelain after apply --dry-run).
• For B: two processes locking the same project through different spellings of its path (symlink, case on macOS/Windows) contend.
• vendor_group_commit_e2e stays green.

Dependencies

Blocked by nothing. Related to the RunCtx tracking issue #793, which would own the session type.