Block acceptance on a question nobody has answered

setup: finish-blocker-open
given:
  - 'an active task with one unresolved question open against it'
steps:
  - id: see-it
    run: ['question', 'list']
    note: 'the open question, numbered, on this branch'
    expect:
      exit: 0
      stdout_contains: ['unresolved', 'tabs']
  - id: refused
    run: ['finish', '--outcome', 'completed', '--verify-command', 'test -d .ai']
    note: 'completion is refused while the question is open; the refusal names it'
    expect:
      exit: 10
      stdout_contains: ['question']
  - id: still-flagged
    run: ['check']
    note: 'check reports the blocker as a failing line, not a warning'
    expect:
      exit: 10
      stdout_contains: ['FAIL']
  - id: resolve
    run: ['question', 'resolve', '1', '--answer', 'tabs are refused; the subset has no tabs']
    note: 'the one line is rewritten as resolved with its answer'
    expect:
      exit: 0
      stdout_contains: ['resolved']
  - id: clear
    run: ['check']
    note: 'nothing blocks now'
    expect:
      exit: 0
      stdout_contains: ['0 failing']
then:
  - 'finish refused with exit 10 while the question was open'
  - 'the resolved entry keeps the question and the answer together'
  - 'check is green once the store holds no unresolved entry'

The scenario

Executed against the real tool, in a repository prepared by finish-blocker-open, 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, 5 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 question list exit 0

   the open question, numbered, on this branch

   1  [unresolved] t-<id> — does the parser need to accept tabs? (<date>)

   • exit 0
   • stdout_contains /unresolved/
   • stdout_contains /tabs/
2. 2$ majordomus finish --outcome completed --verify-command 'test -d .ai' exit 10

   completion is refused while the question is open; the refusal names it

   FAIL blockers    t-<id> — 1 unresolved question(s) on this branch; first: t-<id> — does the parser need to accept tabs?  [reproduce: majordomus question list]
   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)
   OK   verification t-<id> — test -d .ai — exit 0, <s>s, tree <tree>
   INFO obligation  t-<id> — the task declares no obligations
   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, 2 unmet
   blocking doctrines:
   - majordomus.blocker-resolution
   - majordomus.note-integrity

   • exit 10
   • stdout_contains /question/
3. 3$ majordomus check exit 10

   check reports the blocker as a failing line, not a warning

   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
   FAIL blockers    t-<id> — 1 unresolved question(s) on this branch; first: t-<id> — does the parser need to accept tabs?  [reproduce: majordomus question list]
   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  t-<id> — the task declares no obligations
   INFO gate        t-<id> — this repository declares no CI model at .ai/repo/ci/gates.yaml; nothing can be planned
   check: 12 finding(s), 1 failing

   • exit 10
   • stdout_contains /FAIL/
4. 4$ majordomus question resolve 1 --answer 'tabs are refused; the subset has no tabs' exit 0

   the one line is rewritten as resolved with its answer

   resolved for t-<id>: does the parser need to accept tabs?

   • exit 0
   • stdout_contains /resolved/
5. 5$ majordomus check exit 0

   nothing blocks now

   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  t-<id> — the task declares no obligations
   INFO gate        t-<id> — this repository declares no CI model at .ai/repo/ci/gates.yaml; nothing can be planned
   check: 12 finding(s), 0 failing

   • exit 0
   • stdout_contains /0 failing/

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 questionOpen a question that blocks acceptance, resolve it, and list what is still open.
• majordomus finishEvaluate the finish contract and refuse the outcome if any line of it is unmet.
• majordomus checkIs the current task still consistent with its policy, its scope and this checkout?

The rules that make it hold

• ✕blocking Blocker resolutionNo task can be completed while any question on this branch is unresolved; it can still be finished as blocked, partial, no_match or failed.
• ✕blocking Questions store integrityEvery entry in open-questions.md parses, because a gate that cannot read an entry can be bypassed by mistyping one.
• ✕blocking Verification integrityCompletion requires a verification command that actually ran and exited 0 over a tree that did not change under it; its exit code, duration and tree are recorded.

Guarantees exercised

• ○guaranteed An entry in the questions store that does not parse blocks acceptance exactly as an unresolved question does
• ○guaranteed check reports whether state, scope, blockers and checkpoint age are consistent right now
• ○guaranteed finish evaluates the finish contract line by line and refuses when any line is unmet
• ○guaranteed An outcome is a value from a closed vocabulary, not free text
• ○guaranteed An unresolved question blocks acceptance, and an entry the gate cannot parse is a failure rather than a silent pass

Related use cases

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

• Decide whether finished work is actually finishedEvaluate a contract line by line instead of accepting a sentence that says the work is done.
• Hand work over with a question still open, and keep it blockingClose a task into a handover while a question is unresolved, start the follow-up task, and see the same question still refuse acceptance there.
• 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.
• Checkpoint long work so a stop costs minutes, not the dayRecord compact progress inside the active task at the profile interval, so a session that ends without warning leaves the next one a place to start.
• Complete an issue only when its evidence existsSee an issue refuse completion while a required piece of evidence is missing, read the roadmap the milestone state derives, and keep the GitHub projection a projection.

The moments this answers

• → watched a session undo last week's decision, for the reason it was made A decision whose reason lived in a conversation cannot be reviewed, only re-argued — by a worker with less information than the first one had.