Dough Land

Land one reviewed checkout, an owned worktree or the default checkout on the
target branch: commit everything in it, publish that onto the authorized remote
trunk, refresh a supplied default checkout when safe, and retire the worktree
when it is one. Apply completion attention to the final
response. Publication, refresh, and cleanup are separate results.
A later step that stops or is deferred never undoes an earlier one.
With --process-retrospective, also
review this landing's process.

Run only when the developer explicitly invokes Dough Land, or when a calling
skill's own validated keep instruction links here. Reviewing, approving,
pausing, or saying "keep" in passing does not start a landing. Do not open a
pull request, request a hosted merge, or discard anything; when the developer
wants one of those, stop and say that Dough Land does not do it.

Resolve the checkout and target

Resolve both before any commit:

• Landing checkout. The checkout named by the invocation or its context:
  normally the current one, or the owned workspace a calling skill recorded.
  When the context says the change sits on the default checkout, that checkout
  is the one to land. Record its path and branch, whether this work created it
  or reused one another workflow owns, and its starting revision when known.
  Ownership comes from
  that context or the worktree's
  creation record;
  do not infer it from a clean directory. In an
  established session,
  the session's block names this checkout, its role, starting revision, and target.
• Default checkout. The project's established checkout for ordinary work,
  when the context supplies one; the refresh step inspects it. Landing needs no
  default checkout. When the landing checkout is a worktree, the default
  checkout is a different one; when the change sits on the default checkout,
  it is the landing checkout and needs no separate refresh source.
• Target. The authorized remote target as refs/heads/<branch> on a named
  remote: the target selection already recorded for this worktree, or the one
  the project or developer authorizes. Default the branch to main only when
  neither the caller nor the project supplies one.

Stop before committing, and name the gap, when:

• no checkout is in context, or more than one candidate fits;
• the named default checkout is on another branch than the target; name both
  branches;
• the target is missing, contradictory, or not a branch on an authorized
  remote; or
• the checkout has an index.lock or an unfinished merge, rebase,
  cherry-pick, or revert. Name it; the developer resolves it, then reruns.

Commit everything in the checkout

Everything in the checkout is the reviewed change, including unrelated files
and local commits the fetched target lacks. Stage all tracked, untracked, and
deleted paths (git -C <checkout> add -A) and commit them there with a
message describing the reviewed change, as an
agent commit when that
reference applies to the checkout, otherwise with plain git commit; its
refusal stops the landing before publication. When there is nothing to commit, create no commit; that is the
normal rerun case.

The owned unpublished suffix is every commit on the checkout's branch that
the fetched target does not contain. Its previously published base is the last
SHA this landing recorded as accepted, otherwise the checkout's recorded
starting revision, otherwise the merge base of the branch and the fetched
target (for the default checkout, its local HEAD before the commit when that
is contained in the fetched target).

A calling skill that must land only its own record checks, before linking
here, that the worktree holds nothing else. Dough Land does not pick paths out
of a worktree. A preparation keep stages its assignment's release in the
worktree before linking here, so it lands with the result; Dough Land itself
never adds or removes an assignment profile.

Publish

With the original launch's supplied dashboard landing context, use the
launch-bound handoff
for publication and resume. Record its accepted comparison before refresh or
retirement; reporting failure leaves Git acceptance accepted and retries only evidence.

Apply publish the candidate
from the checkout, for that suffix and target; the default checkout is the
owned workspace when it is the one landing; do not invent a second
sequence. The candidate's own changes must be the reviewed checkout content.
On each fetched target, before rewriting the candidate and before the retry
push after a rejection, run this candidate check from the landing checkout:

node <installed>/dough-land/scripts/queued-closure-check.mjs check --checkout <checkout> --remote <remote> --target-ref refs/heads/<branch>

The command fetches the target and checks every queued story the candidate
closes against that tip. It identifies closures from the candidate's merge
base with the fetched target: entries in that base's Backlog list that
are in neither list at HEAD. It needs no retained one-shot context.

Result	Action
clear	Continue publication. An empty closes means no queued story was closed.
ownership-changed	Push nothing; keep the checkout, branch, index, and commit. Report ownership and error, with publication, refresh, and cleanup not done. Leave the story to that owner and the developer.
Other failure	Stop before pushing and report the error; preserve the checkout and Git state.

Do not resolve a backlog reconciliation conflict by removing the other side's
entry. A rewrite onto a newer target rechecks only
proof the combined change affects. Nothing is registered with a CI observer.

A conflict, refusal, failed recheck, or second rejection stops here. Preserve
the checkout, branch, index, and whatever state Git left. Name the conflict or
contention, and report publication, refresh, and cleanup as not done. Do not
loop.

Visit consumers of completed selected work

After accepted publication and before retirement, apply the shared
supplier dependency procedure
when retained context establishes a selected completed supplier. Preserve its
recoverable outcome before cleanup, publish directly justified consumer updates
through this authorized landing workflow, and report unresolved work. A generic
landing or an unfinished increment establishes no supplier completion.

Review this landing's process

Only with --process-retrospective, after accepted publication and any
consumer visit, apply the shared
process review of a run
once per landing, with the landing checkout as the write location. Recorded
findings are uncommitted changes: continue through
Commit everything and Publish
before refresh and retirement.

Refresh the default checkout

After acceptance, when the landing checkout is the default checkout, it is
already at the accepted SHA: record the refresh as already current, or as a
fast-forward to the published trunk when the publication moved it. Otherwise
attempt
Refresh eligibility
on the supplied default checkout for the landed remote and branch.
Record its
maintenance result
and reason separately from publication; apply completion attention
when responding. No refresh result is a failed landing
or blocks retirement.

Another skill may apply this section on its own after its own accepted
publication.

Retire the worktree

Apply owned worktree retirement after
publication and the calling workflow's completion gates. It checks recorded
ownership and target containment, preserves recoverable state on a hold, and
keeps the default checkout in place. Retain supplied dashboard reporting context
outside the checkout before removal; reporting remains the final operation.

Stop, rerun, and report

A stop keeps every resource recoverable (worktree, branch, commits, index, any
default checkout, and the remote as it is) and names the exact unfinished
step. A rerun reads real Git and remote state and continues from the first
unfinished step:

State found	Continue with
Unfinished Git operation in the checkout	Stop and name it
Uncommitted changes	Commit everything
Branch tip not contained in the fetched target	Publish, through the publisher's resume
Tip already contained	Record it as accepted; push nothing. Then refresh, and retire a worktree
Worktree or branch already absent	Record it as already retired

Never commit the same change twice, push an already accepted candidate again,
or create a replacement worktree.

Keep publication acceptance, refresh outcome, and verified resource disposition
as separate operational facts in the command results and available execution
context. Preserve the accepted SHA and target, refresh result and reason, and
cleanup paths and verified disposition for recovery; no new recap or record is
required solely to repeat them.

Completion attention

After operations settle, read and apply the shared
completion attention rule, including its
final dashboard operation with supplied reporting context.