Propose, Acknowledge, Reassign (PAR)

Concurrent work collides when state mutates from more than one pen without an acknowledged handoff token. PAR is the upstream protocol that prevents this — it does not depend on whether the actors are operator + agent, two coworker agents, two Claude sessions in different worktrees, or one session running alongside a chief-architect review pass on the same artifact. The shape is identical in every case.

The three steps

1. Propose. Either side names a piece of work, a decision, or an action and assigns a candidate owner.
2. Acknowledge. The named owner explicitly accepts, modifies, or declines. No mutation begins without this token. The token is recorded as state, not chat text — a workroom lease, a ToolExecution row, a DecisionInteraction outcome, an operator click on a card.
3. Reassign. Completion or mid-stream hand-back is also explicit: session_detach(disposition), release_capsule_scope, a WWMD escalate / defer, a PR opened against the owner’s branch. Silent abandonment is not a valid reassignment.

The cycle then repeats. Either side can initiate the next Propose.

Why this exists

Triggering incident 2026-05-22: a session was asking sequential clarification questions on a spec while a chief-architect pass was mid-edit on the same artifact. Two pens, no handoff token, collision. The clarification-question loop felt fuzzy because ownership was fuzzy.

Four prior concurrency-collision rules are downstream symptoms of the same missing principle:

• worktree-per-session — each concurrent session in its own worktree (collision prevention by physical isolation).
• feedback_git_commit_only_for_concurrent_sessions (memory) — git commit --only <paths> to scope the commit (collision prevention at the commit layer).
• feedback_pr_overlap_check_before_pushing (memory) — sweep main + open PRs before pushing (collision detection before merge).
• feedback_continuous_overlap_check (memory) — re-sweep before every push in long autonomous runs (collision detection during long-lived ownership).

All four work. PAR is what makes them composable instead of an enumerated list of cases.

Operating rules

• No actor mutates an artifact that is currently in an acknowledged-by-another-actor state without first proposing reassignment and receiving acknowledgement.
• Sequential clarification questions to an operator who is mid-edit on the artifact are a PAR violation. The propose step must hold for explicit acknowledgement first.
• Idle acknowledgements expire on a heartbeat budget. Expired ownership is not silently reassigned — it surfaces as stale for explicit adopt-orphan. Per idle-is-not-abandoned (memory feedback_idle_is_not_abandoned), staleness thresholds must absorb operator travel + weekly rate-limit resets (default 7d minimum).
• WWMD escalate and defer are reassignments to the operator UI, not chat pings.
• End every turn with a concrete proposed next step + named owner (a reassign-back), never “Done.” / “Investigating.” / “Your call.” This is the per-turn shape of PAR’s reassign step.

The acknowledgement-as-state requirement

The acknowledgement token must be queryable later. Chat text is not queryable — it lives in a transcript that decays. Acceptable acknowledgement surfaces:

• WorkCapsule.claimedByActor + lastHeartbeatAt (soft lease, with expiry)
• FeatureBuild.phase advancement + phaseRuns row (hard state transition, with audit trail)
• DecisionInteraction.humanOutcome (WWMD-mediated decision, with rationale)
• ToolExecution row for a proposal-mode tool that the operator approved (explicit click, with payload)
• A PR opened against a specific base branch (git is the audit trail)

Unacceptable acknowledgement surfaces:

• “I’ll take it” in chat (no row written)
• A coworker assuming silence == consent
• An operator’s last message being interpreted as a blanket approval for everything subsequent

Anti-pattern

• Two Claude sessions in the same worktree, both staging files, one sweeping the other’s stage into its commit via git add -A.
• An autonomous agent that sees a stale workroom and silently picks up the work without filing an adopt-orphan proposal first.
• A spec-review thread that opens PRs against the spec author’s working branch while the author is still editing the spec.
• A coworker that asks “want me to continue?” three times in a row — that is a missing acknowledgement from the prior turn surfacing as repeated proposals instead of an actual ack.

Penalty

This is a commandment-tier principle. The collisions PAR prevents are not bugs — they are protocol violations. The recovery cost of a single collision (lost staged work, overlapping PRs needing surgical revert, two sessions debugging the same bug from different worktree states) typically exceeds the entire savings of every “I’ll just take it without asking” shortcut combined.

Related principles

• worktree-per-session — physical isolation at the filesystem layer; PAR is the protocol on top.
• worktree-base-origin-main — every new ownership cycle starts from a clean base.
• structured-handoffs-not-conversation-history — the durable artifact PAR’s reassign step produces.
• human-in-the-loop-at-phase-boundaries — phase-boundary approval is the canonical operator-acknowledgement surface.
• do-the-work-dont-task-the-operator — when reassigning back to the operator, propose a concrete next step, not a generic “your call.”
• mention-uncommitted-changes — surfaces the working-tree state PAR needs to compute “who owns this right now.”

Amendment 2026-09-22 — a genuine fork is a button, not a sentence to answer

The reassign step above ends a turn with a proposed next step the owner can accept in one word. Two clauses on its shape.

One proposal, not a menu. A list of options at the end of a turn makes the owner compose a decision before any work can resume. Propose the smallest tractable next step and name it; keep the status report before the proposal, never instead of it.

When there IS a real fork, present it as a choice to click, not prose to type. Recommend one option, put it first, keep the options mutually exclusive and concrete. A one-word reply typed to approve something is pure interface tax, and [[principles/automation-is-measured-by-the-human-steps-it-removes]] counts it.

Do not raise a fork for a step with one correct outcome, and do not raise one at all when a standing directive already said to proceed — that re-asks a question the owner has answered, which is the inversion this principle exists to prevent.

Founder direction, CEO.