Say what reached the remote and what did not

setup: task-owes-outer
given:
  - a repository with the layer installed, an active task that owes commit and push, and the work still in the working tree
steps:
  - id: recording-it-changes-nothing
    run: ['evidence', '--covers', 'commit', '--command', 'git commit']
    expect:
      exit: 0
      output: 'evidence: commit recorded'
  - id: the-tree-is-asked-instead
    run: ['finish', '--outcome', 'completed', '--note', 'done']
    expect:
      exit: 10
      output: 'still in the working tree'
  - id: what-cannot-be-settled-says-so
    run: ['check']
    expect:
      exit: 0
      output: 'the checkout has no remote'
then:
  - a token the tool can settle is settled live at HEAD, and a recorded line neither discharges it nor rescues it
  - a checkout that cannot settle a token falls back to the recorded evidence and says what it could not establish
  - unreachable and unpublished are different findings, and neither is reported as the other

The scenario

Executed against the real tool, in a repository prepared by task-owes-outer, every time this site is generated. What follows is not a description of what should happen; it is what happened.

What the tool did

Evidence of the run this page was generated from: pass, 3 step(s). Output is normalised: the repository's path, timestamps, ids and durations are placeholders; nothing else is edited.

Tested by test/cases/94_use_cases.sh, which runs every scenario and refuses a step whose recorded output is not what it produced.

1. 1$ majordomus evidence --covers commit --command 'git commit' exit 0

   evidence: commit recorded for t-<id>
             note: commit is established from git where it can be, and this record is read only where it cannot

   • exit 0
2. 2$ majordomus finish --outcome completed --note done exit 10

   OK   blockers    t-<id> — none open
   FAIL note        t-<id> — no --note file and no handover for this task  [reproduce: majordomus handover < note.md]
   INFO regression  t-<id> — profile implementation adds no requirement beyond the shared contract
   OK   scope       t-<id> — 1 touched file(s), all within scope
   OK   state       t-<id> — exact (head <head>)
   INFO continuity  t-<id> — applies to partial and blocked
   INFO mesh        t-<id> — the repository declares no enabled mesh
   INFO use-case    30 advisory gap(s) — not covered by an active use case, and the policy does not require it: command:init command:update command:doctor command:watch command:start command:context command:checkpoint command:handover command:check command:finish command:history command:decision command:question command:prompt command:evidence command:skills command:capture command:search command:doctrine command:plan command:version command:session command:knowledge command:adr command:usecase command:rules command:migrate command:recover command:bench command:archive  [reproduce: majordomus usecase coverage]
   OK   use-case    0 of 30 target(s) covered — every public command the policy requires is named and run by an active use case (policy use_cases.coverage)
   FAIL verification t-<id> — profile implementation requires --verify-command  [reproduce: majordomus finish --outcome completed --verify-command "<cmd>"]
   FAIL obligation  commit — 1 file(s) the task touched are still in the working tree, not in the branch's history (lib/a)  [reproduce: git status --porcelain]
   FAIL obligation  push — owed, and no evidence was recorded (the checkout has no remote, so a push cannot be established here)  [reproduce: majordomus evidence --covers push --command 'git']
   INFO gate        t-<id> — this repository declares no CI model at .ai/repo/ci/gates.yaml; nothing can be planned
   INFO gate        t-<id> — not in verification.finish_requires
   finish: refused, 4 unmet
   blocking doctrines:
   - majordomus.note-integrity
   - majordomus.verification-integrity
   - majordomus.obligation-closure

   • exit 10
3. 3$ majordomus check exit 0

   OK   knowledge   records — 0 record(s) valid against knowledge/v1; every reference resolves  [reproduce: majordomus knowledge check]
   ·    checkpoint  t-<id> — <timed against the checkpoint interval>
   OK   records     ledger.jsonl — every line is a well-formed event
   OK   blockers    t-<id> — none open
   OK   records     decisions.md — every entry is attributable
   OK   scope       t-<id> — 1 touched file(s), all within scope
   OK   state       t-<id> — exact (head <head>)
   INFO mesh        t-<id> — the repository declares no enabled mesh
   INFO use-case    30 advisory gap(s) — not covered by an active use case, and the policy does not require it: command:init command:update command:doctor command:watch command:start command:context command:checkpoint command:handover command:check command:finish command:history command:decision command:question command:prompt command:evidence command:skills command:capture command:search command:doctrine command:plan command:version command:session command:knowledge command:adr command:usecase command:rules command:migrate command:recover command:bench command:archive  [reproduce: majordomus usecase coverage]
   OK   use-case    0 of 30 target(s) covered — every public command the policy requires is named and run by an active use case (policy use_cases.coverage)
   INFO obligation  commit — 1 file(s) the task touched are still in the working tree, not in the branch's history (lib/a) (not refused: the outcome is not completed)
   INFO obligation  push — owed, and no evidence was recorded (the checkout has no remote, so a push cannot be established here) (not refused: the outcome is not completed)
   INFO gate        t-<id> — this repository declares no CI model at .ai/repo/ci/gates.yaml; nothing can be planned
   check: 13 finding(s), 0 failing

   • exit 0

Why the tool knows this

The chain from this page to the code: the use case names commands, rules and claims; each rule is dispatched from the registry and each claim names the test that proves it; the scenario above executed the commands. Nothing in this chain is prose about intent.

• majordomus evidenceRecord evidence against the active task: one obligation it declared, discharged, or one validation gate of the CI model that has reported — each as a ledger line carrying the hash of the files it was taken over.
• majordomus checkIs the current task still consistent with its policy, its scope and this checkout?
• majordomus finishEvaluate the finish contract and refuse the outcome if any line of it is unmet.

The rules that make it hold

• ✕blocking Obligation closureA task that declares obligations reaches the outcome completed only when each one is established by the tool or has evidence, and that evidence still describes the tree or the commit it was taken over.

Guarantees exercised

• ○guaranteed An obligation whose fact the tool can hold is established live rather than recorded — a clean tree, a remote-tracking ref that reaches the head, a trunk that reaches it, a published site that serves it — and a hand-recorded line neither discharges it nor rescues it

Related use cases

Computed from what they share: claims, rules, commands, category, applications. Nobody maintains this list.

• Prove what a task owed before calling it doneA task declares what it owes, records evidence against each obligation, and is refused when that evidence no longer describes the tree it was taken over.
• Know whether the work in this checkout is finishedAsk the repository you are standing in, and be told what is still owed by name.
• Decide whether finished work is actually finishedEvaluate a contract line by line instead of accepting a sentence that says the work is done.
• Block acceptance on a question nobody has answeredOpen a question against the task, watch finish refuse completion while it is unresolved, resolve it with the answer, and only then complete.
• Catch an agent that says it is done when it is notOne task, start to finish: a worker strays outside its scope, claims it is finished, hands over, and is accepted only once the repository's own verification passes.