qfai 2.1.2 → 2.2.0

package/assets/init/.qfai/assistant/rule/review-convergence.md

@@ -13,7 +13,10 @@ which owns the delegation rules these sit beside.
   answered, the work proceeds.
 - A finding the author cannot fix is reported in the stage's final report, with
   the finding and why it stays open.
-- A critical decision still goes to the user: one that contradicts a spec, a
+- A critical decision requires actual user authority under
+  `.agents/rules/grilling.md#explicit-delegation-for-a-discussion`.
+  Without an actual answer or recorded applicable authorization, it goes to
+  the user when questions are permitted: one that contradicts a spec, a
   contract or a recorded decision, one whose effect cannot be taken back, or one
   that rests on product intent nothing written states. So does a finding that
   names a concrete security defect, data loss or corruption, or a correctness
@@ -37,7 +40,8 @@ Close a repeat by citing its recorded answer. This bounds what a reviewer may
 require, not what a reviewer may report.
 
 A report of a new defect or evidence that an answer no longer applies must
-state what changed. A critical decision in it still goes to the user.
+state what changed. A critical decision in it still requires actual applicable
+user authority; uncovered authority is never supplied by the review.
 
 ## Discussion review precision
 
@@ -94,7 +98,10 @@ status is not permission to pass those.
 
 A grilling session between agents is a **delegated session**
 (`.agents/rules/grilling.md`): a griller interviews the authors, and the user is
-asked only a critical decision. These rules bound its rounds and say what
+asked only an uncovered critical decision when questions are permitted.
+Actual scoped user delegation may authorize reversible requested judgment
+without an individual option answer; record the agents' adoption and authority
+separately. These rules bound its rounds and say what
 settles each decision when they run out.
 
 **Two rounds.** After the second round **every
@@ -108,8 +115,9 @@ position is recorded beside it with whose it is. The stage reports every adopted
 decision at its end without waiting for an answer. A user who disagrees
 overturns one through a change request or a rerun.
 
-**A critical decision goes to the user at once**, without spending a round.
-Rounds between agents produce agreement, and agreement is not what these lack.
+**A critical decision without an actual answer or recorded applicable user
+authority goes to the user at once when asking is permitted**, without spending
+a round. Agent agreement and round exhaustion supply no authority.
 
 | Critical decision                                                                                                                             | Why it goes to the user                                                     |
 | --------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------- |
@@ -121,15 +129,20 @@ A discussion pack answers product intent for this test. It is non-normative for
 the Drift Protocol, but it is where the user already answered these questions in
 a user session, and asking them again spends that session twice.
 
-Each critical decision goes to the user with every position and a
-recommendation. Escalating is not failure: the work stays where it is and the
+Each uncovered critical decision goes to the user with every position and a
+recommendation when asking is permitted. The work stays where it is while the
 user accepts, decides, or drops the item.
 
 **The budget does not end the session while a critical decision is open.** The
-session ends `adopted` once the user has answered every critical decision.
+session ends `adopted` only with no open node or running lookup, all required
+consumed inputs present, and every critical decision supported by an actual
+user answer or recorded applicable authorization under the master's conditions.
 
-Under a no-question mode the escalation has nobody to reach. A critical decision
-is opened as a question in the register the stage reads, so the stage cannot
-complete over it (`.qfai/assistant/rule/constitution.md` Article X,
+Under a no-question mode no escalation is sent to the user. A critical decision
+without that authority is opened in the register the stage reads, so the stage
+cannot complete over it (`.qfai/assistant/rule/constitution.md` Article X,
 rule 6), and that write ends the session `no-question`. Non-critical decisions
-are adopted as they are in any delegated session.
+are adopted as they are in any delegated session. A qualifying explicitly
+delegated session with every node settled ends `adopted`; no-question mode
+alone does not qualify it. Unknown facts and missing undefaultable consumed
+inputs retain the ordinary open/stop behavior.

package/assets/init/.qfai/assistant/rule/shared-skill-delegation-baseline.md

@@ -34,6 +34,7 @@ classified by the taxonomy below before any response.
   `.qfai/assistant/skill/qfai-implement/references/parallelization-policy.md`.
   Where the stage's ledger or a seam makes an ordering mandatory, carrying on
   does not override it.
+- On Codex, read `.qfai/assistant/rule/references/codex-delegation.md` before delegating.
 - A review is done by an agent that did not author what it reviews. The
   orchestrator never reviews its own work and never approves it for
   convenience.

package/assets/init/.qfai/assistant/rule/shared-skill-operating-baseline.md

@@ -43,7 +43,7 @@ asks nothing and records explicit assumptions in its stage report.
   asked for nor a blocker. Neither exhaustion nor a user's `proceed` / `done` answer is `--auto`, so these questions survive both. Under an explicit `--auto` the question is not asked at all — that run stops and names the missing input instead of inventing one. See `.qfai/assistant/rule/constitution.md` Article VI.
 - **Grilling questions are exempt too, and unbounded.** A question asked inside the interview `.agents/rules/grilling.md` defines spends no budget, and a session runs to its own end condition — for a user session an empty frontier and the user's confirmation, which is itself in the exempt class, and for a delegated one no open node and an answer to every critical decision — rather than to a count.
   An exhausted budget does not close one, because its questions never opened it. A
-  session is entered deliberately: an invocation declares one and nothing else starts one, so a question asked outside a declared session is an ordinary clarification and spends a unit, whatever its subject.
+  session is entered deliberately, only as that rule's § Scope says, so a question asked outside a declared session is an ordinary clarification and spends a unit, whatever its subject.
   Under an explicit `--auto` the session asks nothing, a delegated one still adopts every decision that is not critical, and each node it could not settle is opened as a question in the register the stage reads. Each node, not each decision: a fact only
   the user holds cannot be settled from evidence either, and a fact declared undefaultable stops the run rather than taking a value nobody has. Where a document requires the field to hold something, write the defaulted value and label it an assumption beside that open question; what is forbidden is the assumption with no open question against it (Article X, rule 6).
 
@@ -168,8 +168,8 @@ The `common-gate-run` step runs a gate from this section and records it.
 
 ## Policy check (mandatory)
 
-A run starts with the policy check, once, and does not continue affected work
-on stale policy. The contract is
+A run, an exempt route aside, starts with the policy check once and does not
+continue affected work on stale policy. The contract is
 `.qfai/assistant/rule/workflow.md#policy-check-mandatory`.
 The procedure — which files, what counts as incomplete, how a fact is filled
 and where an unverifiable one goes — is the `common-policy-check` step. A
@@ -255,6 +255,11 @@ stage, and no other.
 4. A finding another owner must repair is reported with that owner, not an
    edit made here.
 
+At each existing stage boundary, read
+`.qfai/assistant/skill/qfai-run/references/reached-step-observations.md`
+for the reached-step comparison in the existing stage report. Preserve the
+plan's scope, termination, pass-through and planned review.
+
 ### A pass-through step
 
 A step the plan marks `passThrough` always runs. It first reads what its

package/assets/init/.qfai/assistant/rule/workflow.md

@@ -132,7 +132,8 @@ from the skills and baselines that cite it.
 ### Policy check (mandatory)
 
 Once per run, at the start, before the first stage. A stage invoked by name on
-its own is a run of its own.
+its own is a run of its own. The ultra-light routes `answer-in-session` and
+`run-operation`, each one step that changes no tracked file, run without it.
 
 1. Check the current story-tree policy files under `<paths.specsDir>`:
    - `01_policy/objective.md` and `01_policy/initiative.md`

package/assets/init/.qfai/assistant/skill/qfai-discussion/SKILL.md

@@ -120,6 +120,12 @@ End the turn with a question listing the next actions, `/qfai-sdd` recommended,
 
 ## Default Autopilot Policy
 
+The entries below govern the default user interview. Only an actual user
+delegation recorded under
+`.agents/rules/grilling.md#explicit-delegation-for-a-discussion` enables the
+delegated `adopted` path. No-question mode alone does not enable it; missing
+inputs and uncovered human decisions retain their ordinary blocking behavior.
+
 - ask-user:
   - every decision the interview puts on the frontier, over every topic in `references/discussion-coverage-checklist.md`. Running the interview is what this skill performs, so these are its own operations
   - the confirmation that closes the session

package/assets/init/.qfai/assistant/skill/qfai-discussion/references/discussion-completion-matrix.md

@@ -22,13 +22,14 @@ Blocking for every pack, UI-bearing or not:
    resolves to a `sources[].id`, and at least one `reflection[]` entry records an apply decision.
    `npx qfai validate --profile discussion --fail-on error` reports `QFAI-RESEARCH-*` until it is.
 2. The stage report's `## Grilling Session` row shows the session ended before authoring began,
-   with `Ended` reading one of the three endings that authorize it:
+   with `Ended` reading an authoring ending and its conditions met:
 
-   | Ended         | Also required                                                                                                  |
-   | ------------- | -------------------------------------------------------------------------------------------------------------- |
-   | `confirmed`   | No node open — the frontier empty **and** no fact lookup still running                                         |
-   | `user-closed` | Lookups finished, and every decision still open recorded as a labelled assumption                              |
-   | `no-question` | Every node still open registered — a decision, and a fact only the user holds — so item 3 below is what blocks |
+   | Ended         | Also required                                                                                                                                                                                        |
+   | ------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+   | `confirmed`   | No node open — the frontier empty **and** no fact lookup still running                                                                                                                               |
+   | `user-closed` | Lookups finished, and every decision still open recorded as a labelled assumption                                                                                                                    |
+   | `adopted`     | Recorded explicit delegation, actual author rounds, no open node or lookup, all required inputs and applicable human authority; see `.agents/rules/grilling.md#explicit-delegation-for-a-discussion` |
+   | `no-question` | Every node still open registered — a decision, and a fact only the user holds — so item 3 below is what blocks                                                                                       |
 
    `stopped` never completes: the user ended the run, and a pack authored after that is the run
    doing what they told it not to.
@@ -44,6 +45,10 @@ Blocking for every pack, UI-bearing or not:
    covered, every open question registered. What is missing is that someone agreed to what is in
    them, and nothing downstream can tell.
 
+   Delegation is not a human confirmation or a completion receipt. The
+   ordinary research, pack, OQ, UI, schema, validation and independent-review
+   gates remain blocking. No reserved decision or missing fact is forced closed.
+
    The no-question row is the one to read carefully: `--auto` can reach nobody, so waiting for a
    confirmation would stop the run before it could write the open questions that are what block it.
    Item 3 below does that work instead — an open count above zero closes nothing.
@@ -53,7 +58,7 @@ Blocking for every pack, UI-bearing or not:
    Here rather than under one pack shape. It is what a no-question run is blocked by, and a run is
    `--auto` or not independently of whether it has a surface — listed only under `## UI-bearing
 Packs`, it let a non-UI `--auto` pack complete with its decisions still open.
-   Item 7 below does that work instead — an open count above zero closes nothing.
+   All Packs item 3 does that work — an open count above zero closes nothing.
 
 ## UI-bearing Packs
 
@@ -73,7 +78,11 @@ Completion is blocked until all are true:
 5. `01_Context.md#Design Direction` names an adopted theme, what departs from it, and what stays
    ordinary. This is the one visual decision made here, because no later stage asks the user for
    it: `/qfai-sdd`'s `common-design-md` step authors tokens from whatever is recorded. A direction taken without the
-   user carries `chosen_by: assumption` and an open entry in `11_OQ-Register.md`.
+   user carries `chosen_by: assumption`, never `user`. Its OQ stays open unless
+   an actual specifically applicable user instruction overrides the human-choice
+   requirement under the master's conditions; record that authority and the agents'
+   choice without falsifying the schema. General delegation alone does not waive
+   a genuinely reserved human input.
 
 Evaluation axes are global constants (4-step ordinal: weak / acceptable / strong /
 exceptional) and are NOT authored as discussion sidecars.
@@ -90,7 +99,7 @@ so conditions 1 and 5 above do not apply to it:
   `validators/designContractReadiness.ts` skips `QFAI-DCON-030`/`-033`/`-034` for it.
 - No design direction either: nothing downstream reads a theme for a surface that renders
   no tokens.
-- Conditions 2, 3, 4 and 7 apply unchanged: all three canonical `uiux/` sidecars, the
+- UI-bearing items 2, 3 and 4 and All Packs item 3 apply unchanged: all three canonical `uiux/` sidecars, the
   full screen-contract schema, unranked exploration directions, and zero open OQs.
 - `route:` on a `cli` screen contract names the command invocation, not a web path, as the `cli` section of the UI-bearing playbook sets out.
 - No `prototyping.yaml`: `cli` is not a valid prototyping execution surface.

package/assets/init/.qfai/assistant/skill/qfai-grilling/SKILL.md

@@ -24,11 +24,15 @@ shared, closes the asking, or stops the session, a delegated session adopts the
 griller's recommendations, or a run that may not ask writes every node left
 where its stage's gate reads it.
 
-**Which kind of session runs is the invoking stage's to say.** A stage whose
-work is the interview holds a user session; every other stage holds a delegated
-one, where a griller interviews the authors and the user is asked only a
-critical decision (`.agents/rules/grilling.md` § Two kinds of session). A stage
-that says nothing holds a delegated session.
+**The invoking stage picks the session.** A stage whose work is the
+interview holds a user session; any other holds a delegated one, where a griller
+interviews the authors and only a critical decision reaches the user, and only
+for a decision the repository cannot settle (`.agents/rules/grilling.md` § When
+a session is held). Without one, no griller starts. A stage that says nothing
+holds a delegated session where one is held. Read
+`.agents/rules/grilling.md#explicit-delegation-for-a-discussion` before
+delegating a user discussion; record actual authority. No-question alone is not
+delegation.
 
 **The request bounds the tree** (`.agents/rules/grilling.md`). A decision whose
 only outcome is whether to add something the request did not ask for is left
@@ -53,7 +57,8 @@ least beyond the request.
 | A no-question mode is active        | Run without asking; open every node left over as a question |
 | An ambiguity met while implementing | Not a session — stop under Article IX of the constitution   |
 
-**A no-question mode silences the questions, not the session.** An invocation
+**A no-question mode silences user questions, not the session.** The master's
+explicit-delegation conditions permit author rounds. Otherwise, an invocation
 told not to ask — `--auto`, or whatever the host spells it as — settles what the
 evidence settles, dispatches the lookups, and opens every node left over as
 a question in the register the stage reads, so the stage cannot complete over
@@ -115,19 +120,17 @@ re-opens it.
 1. Recompute the frontier from what is now settled.
 2. Dispatch the fact lookups the remaining decisions wait on. Do not block the
    round on them.
-3. Put the whole frontier at once, so the user sees what is being decided
-   together.
+3. Put the whole frontier at once to the session's answerer: the user by
+   default, or authors in a qualifying delegated session.
 4. Read the answers, then return to step 1.
 
 Two questions never share a round when one depends on the other; the dependent
 one belongs to a later round. The next round is never written ahead of the
 answers it is computed from.
 
-**A no-question mode is read before any of this.** Where the invocation is told
-not to ask — `--auto`, or whatever the host spells it as — no round is put at
-all, so nothing below applies and the no-question section above governs. A mode
-that withholds the tool while still permitting questions is a different thing,
-and is the fallback's case.
+**A no-question mode is read before any of this.** Agent rounds require
+explicit delegation; otherwise the section above governs. A withheld tool with questions still
+permitted uses the fallback.
 
 **Three things send a round to plain text**: the host has no structured question
 tool, the current mode withholds it while still permitting questions, or the
@@ -214,18 +217,22 @@ simple.
 **A delegated session has no condition 2**, because no user is there to
 confirm. A budget bounds its rounds: two, then every decision that is not
 critical takes the griller's recommendation — the ones the agents agreed on and
-the ones still open alike — and every critical decision goes to the user at
-once, without spending a round
+the ones still open alike. An uncovered critical decision goes to the user
+when asking is permitted, without spending a round
 (`.qfai/assistant/rule/review-convergence.md`). It ends `adopted` once
-no node is open and the user has answered every critical decision.
+the master's conditions hold: no open node or lookup, required inputs present,
+and actual authority for critical decisions. Record agent choices as agents'.
 
-**The budget ends the rounds, not the session.** While a critical decision is
-unanswered the session is still open: the user answers it, or ends the session
+**The budget ends the rounds, not the session.** While a critical decision
+lacks an actual answer or applicable recorded authorization, it stays open: the user answers it, or ends the session
 another way — or, under a no-question mode, the register write ends it
 `no-question`. How many went is a count a record carries, never an ending.
 
-**A session under a no-question mode cannot reach condition 2 either**, because
-there is a user and the mode forbids asking them. It ends when nothing on the
+**Only a no-question session meeting the master's explicit-delegation
+conditions ends `adopted`.**
+
+**Any other session under a no-question mode cannot reach condition 2
+either**, because the mode forbids asking the user. It ends when nothing on the
 frontier is still waiting: every decision the evidence settled is settled, and
 every one it did not is opened as a question where the stage's own gate reads it
 (`.qfai/assistant/rule/constitution.md` Article X, rule 6). The register
@@ -350,6 +357,9 @@ Every decision this skill meets falls in one of three named buckets.
   - grilling subject (the design to interrogate; a session has no default for
     what it is about)
 
+Explicit delegation is not `auto-decide` or a fact or human answer.
+These user-session entries remain the default.
+
 The asking is what this skill performs, so its `ask-user` entries are its own operations
 rather than an entry added to the prototype.
 

package/assets/init/.qfai/assistant/skill/qfai-grilling/references/delegated-session.md

@@ -53,6 +53,7 @@ decisions belonging to different drafting roles.
   report lists it; nothing waits for the user to read it.
 
   A critical decision is the exception: agreement closes its node for the
-  round, and only the user's answer settles it. Recording an agreed critical
-  decision as settled is how a choice nobody with the standing made reaches a
-  draft.
+  round, but only an actual user answer or an explicit applicable authorization
+  under `.agents/rules/grilling.md#explicit-delegation-for-a-discussion` settles
+  it. Record that authority separately from the agents' positions. Agreement
+  alone does not settle it, and an unknown user-held fact still stays open.

package/assets/init/.qfai/assistant/skill/qfai-grilling/references/session-record.md

@@ -18,7 +18,9 @@ Use the shared schema from
 The invoking stage's reviewer confirms this about the session:
 
 - no decision was recorded as the user's that the user did not answer, no
-  critical decision was adopted without them, and none was assumed that the
+  critical decision was adopted without an actual user answer or an explicit
+  applicable human authorization under the master's delegation conditions,
+  and none was assumed that the
   assumption path excludes;
 - every adopted decision has its `agents` row, and none of them adds what the
   request did not need;
@@ -27,7 +29,11 @@ The invoking stage's reviewer confirms this about the session:
   five endings `.agents/rules/grilling.md` names. Between agents a round budget
   bounds the rounds (`.qfai/assistant/rule/review-convergence.md`), and
   a session recorded as ended while a critical decision it escalated is still
-  unanswered is the finding.
+  unanswered and lacks that recorded authority is the finding;
+- for an explicitly delegated discussion, the actual user instruction, its
+  scope and authority, actual author rounds and dissent, no open node or
+  running lookup, all required consumed inputs, and actual end/authoring times
+  are evidenced. `adopted` without these is not a passing session.
 
 The reviewer works under these rules:
 

package/assets/init/.qfai/assistant/skill/qfai-implement/SKILL.md

@@ -40,6 +40,7 @@ steps:
   - implement-tooling
   - implement-backport
   - implement-acceptance
+  - implement-procedure
 requires: [common-review-cycle]
 mode: approval-gated
 ---
@@ -136,6 +137,12 @@ and reporting requirement, and states any assumption it built on
 (`.qfai/assistant/rule/test-layers.md#test-suite-sizing`,
 `.agents/rules/minimal-implementation.md` § 4).
 
+## Route-only procedure authoring
+
+When the plan names `implement-procedure`, follow
+`.qfai/assistant/step/implement-procedure/STEP.md`.
+Business-flow invocations skip it; existing flow steps apply.
+
 ## Completion
 
 The invocation completes on the gate of its last step once

package/assets/init/.qfai/assistant/skill/qfai-implement/references/ui-affecting.md

@@ -20,8 +20,8 @@ product-surface-reviewer. Do not infer that a change has no UI effect from its d
 
 ## Evidence
 
-For a UI affecting example, report the screen state, action, expected and observed result, and a capture or rendered artifact. The artifact must identify the source revision. In the stage review, product-surface-reviewer judges each UI affecting example, its UI contracts, and its captured state. The review verdict refers to that revision.
+For a UI affecting example, report the screen state, action, expected and observed result, and a capture or rendered artifact. The artifact must identify the source revision. In the review that reads the change, product-surface-reviewer judges each UI affecting example, its UI contracts, and its captured state. The review verdict refers to that revision.
 
-If the implementation or capture changes after the verdict, refresh the capture and review. A passing code test cannot substitute for the visual and interaction evidence that the acceptance criterion requires.
+A fix made for a finding of that review refreshes the capture it changes and is not reviewed again (`.qfai/assistant/rule/review-convergence.md#one-review`). A passing code test cannot substitute for the visual and interaction evidence that the acceptance criterion requires.
 
 Capture each declared task at a desktop width and a narrow width, in the normal state and in every declared empty, error, loading and success state the screen has. A text the contract declares that the capture lacks, or a text the capture shows that the contract does not declare, is a finding.

package/assets/init/.qfai/assistant/skill/qfai-run/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: qfai-run
 title: QFAI Run (Change request entry)
-description: "Use when the user asks for a change, a fix, an investigation of the codebase or a question about the project in plain words and names no stage skill. A question that one command or one file read answers needs no plan. Plans the request with `npx qfai workflow plan` and runs the plan's steps in order to its end."
+description: "Use when the user asks for a change, a fix, an investigation of the codebase, a question about the project or an operation on finished work in plain words and names no stage skill. Plans every such request, the lightest included, with `npx qfai workflow plan` and runs the plan's steps in order to its end."
 argument-hint: "<the change, in your own words>"
 allowed-tools: [Read, Glob, Grep, Write, Edit, Bash, TodoWrite, Task, Agent]
 roles: [orchestrator]
@@ -14,14 +14,15 @@ mode: execution-focused
 
 [DRIFT-PROTOCOL:REQUIRED]
 
-The CLI plans; this skill follows its steps in order.
+Follow the CLI plan's steps in order. Read no reference up front; each line says when.
 
-- Read `references/extraction.md` to extract a request.
-- Plan command and format: `references/plan.md`.
-- Screens and questions: `references/operator-screens.md`.
-- Release, decision and branch points: `references/stage-points.md`.
+- `references/extraction.md`: for an extraction step 1 does not give.
+- `references/plan.md`: for a plan field this file does not name, or a refused plan.
+- `references/operator-screens.md`: when a line below or a step names it, such as to ask or report.
+- `references/stage-points.md`: at a step the plan marks with a point.
 - Run preflight before planning, as `.qfai/assistant/rule/shared-skill-operating-baseline.md#canonical-qfai-launcher-mandatory` says.
   If the launcher is missing or preflight fails, read `references/operator-screens.md` for recovery.
+- Read `references/codex-cloud-install.md` before configuring an environment-owned Install script or Start skill, or preparing dependencies for a fresh checkout. Use the reviewed target's successful preparation and canonical proof before planning.
 
 ## What this skill never does
 
@@ -34,8 +35,8 @@ The CLI plans; this skill follows its steps in order.
 
 ## Mode
 
-Read `workflow.mode` in `qfai.config.yaml` first. No key means `active`; any
-value but the three below plans nothing.
+Read `workflow.mode` in `qfai.config.yaml` first. No key means `active`; unlisted
+values plan nothing.
 
 | Mode     | What this skill does                                                                 |
 | -------- | ------------------------------------------------------------------------------------ |
@@ -47,52 +48,52 @@ value but the three below plans nothing.
 
 - For independent targets under one goal, read `references/operator-screens.md`
   before planning or switching during a wait.
-- A change, a question, a proposal to decide or a report to close is planned.
-  A question plans a route that answers it and changes nothing. Text that is
-  not a request is not planned.
-- A reply with a requested answer or result resumes the same step without a new
-  invocation, including failure. An independent new request is planned. Read
-  `references/operator-screens.md` for replies.
+- Plan changes, questions, proposals to decide and reports to close.
+  Questions plan answers without changes; nonrequests get no plan.
+- Replies with a requested answer or result, including failure, resume the same step without
+  a new invocation. An independent new request is planned; read `references/operator-screens.md`
+  for replies.
 - `stop`: end the work at once and list every open decision as open.
 - A request naming a stage skill: invoke that skill by name.
 
 ## The work
 
-1. **Extract.** Read the request into an extraction as
-   `references/extraction.md` sets out, using its definition of acceptance.
-   Pass the extraction to
-   `npx qfai workflow plan --in <file>`, or `--in -` on standard input.
+1. **Extract.** A question one read answers is `{ intent: question-why, qualifiers: [session-answerable] }`
+   (or `question-how`, `question-help`); an operation on finished work that the session runs itself and
+   that deletes nothing is `{ intent: order, artifacts: [] }`. Every other field is empty, with
+   `confidence: high`; neither needs a reference. Read any other request as `references/extraction.md`
+   sets out, and pass the extraction to `npx qfai workflow plan --in <file>`, or `--in -`.
 2. **Candidates.** When `plan` returns `candidates`, put one single-select
    question, each option saying in the user's words what that route will do,
    then run `npx qfai workflow plan --route <route>` for the chosen one.
-3. **Scope.** With two or more scopes, ask which to run as
-   `references/operator-screens.md` says, and run only its stages.
-   With one scope, no scopes, or a branch destination's plan, ask nothing and
-   run every stage.
-4. **Announce.** Before the first stage, give the goal, the chosen stages in
-   order in plain words, and the files the work may change. Ask nothing. Then run
-   `common-policy-check` once. On a route that changes no file, one that
+3. **Scope.** With two or more scopes, ask which to run as `references/operator-screens.md` says,
+   and run only its stages. With one scope, no scopes, or a branch destination's plan, ask
+   nothing and run every stage.
+4. **Announce.** Before the first stage, give the goal, the chosen stages in order in plain words,
+   and the files the work may change. Ask nothing. Then run `common-policy-check` once, unless the
+   plan's one step is `triage-answer` or `triage-operate`. On a route that changes no file, one that
    closes, answers or asks, it reads and reports and writes nothing.
 5. **Run the stages.** Run each stage in plan order, and each of its steps in
    order, as `.qfai/assistant/rule/shared-skill-operating-baseline.md#running-steps-mandatory` says.
    When a step is short or passes without edits, read `references/operator-screens.md`.
    Write artifacts yourself or delegate independent parallel work or review.
-   At each step, follow its plan's points in `references/stage-points.md`:
+   At a step the plan marks with a point, follow `references/stage-points.md`:
    - **Release point.** Ask the user to approve the release before the step `releasePoint` names.
    - **Decision point.** Put each critical decision at a step `decisionPoints` names to the user.
    - **Branch point.** Move to the destination a step `branchPoints` names, and plan it at once.
-6. **Review.** After a stage whose `review` is `spec`, `requirements-reviewer`
-   reviews, with `architecture-reviewer` when a contract changed; after one
-   whose `review` is `code`, `implementation-reviewer`.
-   `product-surface-reviewer` joins both where a UI contract with screens
-   serves the flow. No agent reviews its own work, and no step adds a review.
-   Each review returns PASS or REVISE, and each finding is fixed or answered
-   once, with no re-review. A step that would go beyond the request stops.
+6. **Review.** After a stage whose `review` is `spec`, `requirements-reviewer` reviews; for `code`,
+   `implementation-reviewer`. Only a contract or screen change no earlier review read adds
+   `architecture-reviewer` or `product-surface-reviewer`, as `common-review-cycle` lists; no one else
+   joins. A review whose target's only edits resolve the conflicts of a merge or branch update between
+   reviewed sides gets no reviewer.
+   No agent reviews its own work; no step adds a review. Each returns PASS or REVISE.
+   Fix or answer each finding once, with no re-review. Stop a step that exceeds the request.
 7. **Approvals.** Each approval of a specification change, a critical decision
    or a release is one `decisions.md` row: what was approved, who approved it,
-   when, and the chosen option's label. A decision you took appends no row.
+   when, and the chosen option's label, in the `qfai-sdd` decisions template's form. A decision you took appends no row.
 8. **A finding no stage serves.** Stop, and name the finding, its owner and the stage skill to invoke by name.
 9. **Commit.** `verify-commit` runs last, after any release point; never pushes.
+10. **Session feedback.** When the final report closes the user's last task and nothing waits on them, follow `.agents/rules/session-feedback.md` once.
 
 ## Under a no-question mode
 
@@ -135,12 +136,13 @@ When parts ran in parallel, use the summary in `references/operator-screens.md`.
 
 ## Completion Contract (Shared)
 
-Follow `.qfai/assistant/rule/shared-skill-operating-baseline.md#completion-contract-shared`. **Smallest applicable smoke check** (this skill's override): the gates of the `verify-qfai-gate` and `verify-repo-gate` steps the chosen scope holds; a scope holding none runs no gate, and the report says so. A gate that cannot run is UNRUN, not a pass.
+Follow `.qfai/assistant/rule/shared-skill-operating-baseline.md#completion-contract-shared`. **Smallest applicable smoke check**: the chosen scope's `verify-qfai-gate` and `verify-repo-gate` gates. With none, run no gate and report it. Unavailable gates are UNRUN, never PASS.
 
-When the request requires evidence handover before session archive, read
-`references/evidence-delivery.md` and complete its receiving proof first.
-Missing access keeps the handover pending and originals retained. Ordinary
-completion does not require an unsolicited upload.
+At stage boundaries, follow `references/reached-step-observations.md` in the existing report.
+
+If requested evidence handover must precede archive, read `references/evidence-delivery.md`
+and complete receiving proof first. Missing access leaves handover pending and originals
+retained; ordinary completion requires no unsolicited upload.
 
 project_memory:
 

package/assets/init/.qfai/assistant/skill/qfai-run/references/codex-cloud-install.md

@@ -0,0 +1,80 @@
+# Codex Cloud dependency preparation
+
+Read before configuring an environment-owned Install script or Start skill, or
+when a fresh checkout cannot pass the canonical launcher preflight. Init writes
+the preparation entry and this guide; it performs no installation or host setup.
+
+## Before execution
+
+Review the project-declared executable, separate argv and absolute checkout cwd.
+Read the declared Install command from the project's Standard commands; translate
+it into a reviewed native executable and arguments before configuration. The entry
+does not parse Markdown, shell text or choose a package manager.
+
+Covered authority for the command and its lifecycle scripts must already exist.
+Preserve network, secret, trust and publication permissions. A generated file,
+invocation or flag grants no authority. Missing authority blocks execution.
+Review argument and output contents before retaining or sharing them.
+
+## Install script
+
+Use the generated entry with the reviewed tuple:
+
+```text
+node .qfai/assistant/skill/qfai-run/scripts/codex-cloud-install.mjs --cwd <absolute-checkout> -- <executable> [argument...]
+```
+
+Replace the placeholders with the reviewed values and configure the host's
+supported Install script. The executable and arguments are passed with no shell
+parsing at the explicit cwd. Do not supply an entire shell command as one argument.
+Do not use a parent, remote or cached command as a substitute.
+
+Missing inputs, an unknown option, a relative cwd or an unreadable target directory
+fail before installation. Unavailable tools, spawn errors, signals, nonzero exit
+and observed timeout remain failed preparation. Retain the actual reason; there
+is no automatic retry, extra timeout option or new deadline.
+
+After successful installation the entry checks the same cwd for its local
+`node_modules/.bin/qfai`, or a root `.pnp.cjs` / `.pnp.loader.mjs` marker with a
+declared qfai dependency and native `yarn exec qfai --help` exiting 0. A failed
+installation stays failed even if a launcher already exists. A Windows wrapper
+that cannot start natively remains a tool failure; no shell fallback is added.
+
+## Start skill
+
+Check successful preparation and the canonical proof at the same reviewed cwd
+before dependent planning. Failure or missing covered authority blocks planning;
+report the actual blocker and owner required to resume. The entry starts no plan.
+Use the launcher that the existing canonical preflight established for that target.
+Preparation is neither global validation nor formal workflow completion.
+
+## Environment setup
+
+Confirm current environment support for the Install script and Start skill before
+real configuration. The operator performs authorized setup and publication;
+init and the generated entry do not register an account or configure the host.
+
+Saving configuration, preparing and publishing a filesystem for new tasks are
+distinct operations. A refresh does not rerun installation or startup. Existing
+tasks retain their own state. Confirm the actual host behavior before claiming
+that preparation or a Start skill ran for a task; changing a local file is not
+evidence of a published environment or a new task using it.
+
+## Reminders and trust
+
+Existing reminder-only exit-0 behavior stays unchanged. Project-edited hook groups
+keep their existing merge behavior. Keep linked-path refusals, unreadable-file warnings and hook
+review. Preparation does not grant hook trust. No universal SessionStart installer
+is added, and reminder hooks do not perform this installation.
+
+## Evidence limits
+
+Distinguish generated assets, controlled native CI and actual Cloud configuration,
+publication or task execution. Retain reviewed command and argv, cwd, actual exit
+or signal, and canonical result without exposing secrets. A failed or interrupted
+run is not ready; missing outcomes remain unknown.
+
+Controlled native fixtures cannot prove host lifecycle or startup execution.
+Actual Cloud setup and execution remain unobserved without their own receipts.
+Keep existing workflow gates, trust and independent review; preparation replaces
+none of them.