@sabaiway/agent-workflow-kit 14.12.0 → 14.13.0

package/CHANGELOG.md

@@ -4,6 +4,34 @@ Semantically versioned ([semver](https://semver.org)), newest first. The `versio
 is the current release. `upgrade` mode reads a project's `docs/ai/.workflow-version` and applies
 every `migrations/<version>-<slug>.md` newer than it, in semver order.
 
+## 14.13.0 — every session close tells you what was done and what comes next, and a project without a work queue is offered one (AD-159)
+
+**Your agent now ends a session with two short blocks written for you, and the handover keeps them.** Until 14.13.0
+the rules file did not ask for these two blocks, no memory template had a place for them, and a
+project with no `docs/plans/queue.md` had to write one by hand. 14.13.0 adds the rule, the slot, a checker for the
+slot, and a queue seed on the upgrade's existing one yes. Story S5 of the epic `CONSUMERS-MOVE-ONTO-THE-FULL-FLOW`;
+contract `docs/ai/specs/kit/tier/session-rules/` (new).
+
+- **Two rules in the rules template.** §2.5 Communication gains the bullet `Two blocks for the user`: at a plan's
+  approval, at a release and at every session close the message body carries *What was done, and for what* and
+  *What is next, and why*, in the dialogue language, with no internal ids and no review-round tallies. §2.7 Story
+  sessions gains one sentence: inside the tests and code sessions each task runs as its own carrier session. The
+  upgrade's `lens` step refreshes a region still equal to the text an earlier kit shipped, without an ask; a region
+  you edited is kept and flagged, as before.
+- **A `For the user` slot.** The handover template gains a `## For the user` section with the two labels, and the
+  changelog template's entry a `**For the user:**` line after its Goal. A project bootstrapped from now on starts with
+  them.
+- **`tools/session-close-check.mjs --check [--cwd <project>]`.** Read-only: it judges the `## For the user` section of
+  `docs/ai/handover.md`. Exit 0 prints one accept line; 1 prints every refusal found, one per line, each by its name; 2 is a usage error or a state it cannot judge,
+  named. It checks that both labels carry text, never what language the text is in or what it says. It is not
+  offered as a gate: a session close is not a commit.
+- **The upgrade offers a work queue.** The `tier` step's registry gains two entries after `checker-gates-declared`.
+  `named-queue-row-seed` offers to seed a missing `docs/plans/queue.md`; on the same one yes,
+  `tools/tier-preview.mjs --apply` writes it, create-only, from the kit's `references/authoring/QUEUE_TEMPLATE.md`:
+  the named-row rule, the purge archive, priority order and the check line, and four empty buckets. An existing queue
+  is never touched, and `queue-audit-cli`'s `--require-names` stays opt-in. `session-close-rules` only reports whether
+  both rules are current in your rules file; it never offers a write.
+
 ## 14.12.0 — the upgrade offers the kit's own checkers as gates of your project, each only where it can run (AD-158)
 
 **The kit's own checkers can now be declared as gates of your project without a hand edit.** Until 14.12.0 no

package/SKILL.md

@@ -3,7 +3,7 @@ name: agent-workflow-kit
 description: Deploy or upgrade a portable AI-agent memory-and-workflow system in any project. Use when the user wants to bootstrap `docs/ai/` + an entry-point `AGENTS.md` (+ `CLAUDE.md` alias) + cap/archive/index enforcement in a new or existing repo, set up the Memory Map and session protocols, install the docs-rotation pre-commit hook, or run `/agent-workflow-kit` / `/agent-workflow-kit upgrade`. Triggers on phrases like "set up the memory system", "deploy the AI workflow here", "bootstrap docs/ai", "upgrade the workflow". New to the epic, story and task tier? Run `/agent-workflow-kit tier`.
 disable-model-invocation: true
 metadata:
-  version: '14.12.0'
+  version: '14.13.0'
 ---
 
 # agent-workflow-kit

package/capability.json

@@ -3,7 +3,7 @@
   "schema": 1,
   "name": "agent-workflow-kit",
   "kind": "composition-root",
-  "version": "14.12.0",
+  "version": "14.13.0",
   "provides": [],
   "roles": {},
   "detect": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sabaiway/agent-workflow-kit",
-  "version": "14.12.0",
+  "version": "14.13.0",
   "description": "Portable, cross-agent memory & workflow for AI coding agents — Claude Code, Codex, Cursor, Devin Desktop. One command deploys an AGENTS.md entry point + docs/ai context with cap/archive/index enforcement into any repo.",
   "keywords": [
     "ai-agents",

package/references/authoring/QUEUE_TEMPLATE.md

@@ -0,0 +1,19 @@
+# Work queue
+
+> This file names work; it never holds the analysis of it. A row opens with one plain sentence
+> saying what the work is for, then its ALL-CAPS id, then a short body.
+> A row that goes terminal leaves the queue in the change that mints its closing artifact; where
+> this file is gitignored, first snapshot the section to a purge archive with
+> `queue-purge-cli.mjs snapshot`, because git history keeps no tombstone.
+> Order inside a bucket is priority.
+> Check: `node <kit>/tools/queue-audit-cli.mjs --check docs/plans/queue.md --require-names`
+
+## Queue
+
+### Now
+
+### Next
+
+### Later
+
+### Frozen

package/references/templates/agent_rules.md

@@ -73,6 +73,7 @@ Apply this as part of §2 before any user-facing summary:
 - **Live host/session facts are tool-composed only.** Any claim about the current host or session state (prompts fired, sandbox scope, whether a bypass was needed, network reachability, approval counts) must trace to **live tool output** from **this session**; a memory/handover snapshot is **context, never report facts**, and a claim with no live signal is **omitted or explicitly marked unverified** — never asserted from recollection.
 - **The closing state block answers three DIFFERENT questions.** Close a user-facing message with three labelled slots — *now* · *what I need from you* · *what's next*. The slot LABELS stay ENGLISH — an English label is what lets a state-block checker FIND the block and its slots at all; everything written INTO a slot is in the project's dialogue language; when that language is not English, the checker's English phrase sets do not judge those values. **Now** = the state at this instant: what is RUNNING, or what the work is stopped on. It is **never a report of finished work** — what you completed goes in the message BODY, above the block. **From you** = the real unblocker, named; a turn that is ENDING always has one. **Next** = what follows. A *now* slot that opens with what was completed buries the one fact the reader opened the message for, and the three slots collapse into one restatement.
 - **A skip that contradicts the tree is a finding.** A tool-composed `skipped-*` line whose stated reason the observed tree disproves (a "no Node" skip beside deployed Node scripts) is raised as a FINDING in the report, never pasted as a neutral outcome — and a tool may not emit a skip whose reason it could itself disprove.
+- **Two blocks for the user.** At a plan's approval, at a release and at every session close, the message BODY — above the closing state block — carries two short blocks in the dialogue language. *What was done, and for what*: per item the user-facing problem, then what now exists; a command name is allowed, an internal id is not. *What is next, and why*: each proposal names its benefit, plus the one hand step if any. No internal ids, no review-round tallies. The same two blocks are the handover's `## For the user` section, which the kit's `session-close-check` checker judges at the close, where the kit is installed.
 
 ### 2.6. Planning, review & process-fidelity invariants
 Apply these when authoring a plan, reviewing, folding a finding, or editing code — the layer read **before any code change**. (Full canon: the project's planning / workflow-methodology + orchestration canon. This section is rendered from that canon and refreshed on upgrade; a custom edit is preserved verbatim, but flagged.)
@@ -93,7 +94,7 @@ Apply these when authoring a plan, reviewing, folding a finding, or editing code
 - **Cost lanes.** Route every step to the **cheapest adequate executor** — L0 deterministic script (the batched gate matrix over `gates.json`, the rotation `--check`s) · L1 cheap subagent (extraction/drafting only; the orchestrator verifies) · L2 subscription bridge · L3 frontier judgment. A step with **no named guardrail does not move down** a lane, and the **red lines never move down** (council review models · real code · ADR/handover/changelog-entry wording · persuasive copy · go/no-go · the approval asks). Own-error repair: salvage recorded state first (L0/L1, batched), never frontier re-derivation. **Prompt economy:** read-only fan-out (research/sweeps/extraction) runs ONLY on restricted-tool vehicles — a full-tool subagent for read-only work is a forbidden lane downgrade (invisible prompt-flood + blast radius), and a subagent is never told to shell out for facts obtainable read-only; the orchestrator's own shell form is ONE plain pipeline per call (a `;`/`&&` chain or env-prefixed invocation never matches a prefix allow rule); a fan-out launcher that gates per call yields to the agent-spawn lane — capability-gated: without restricted-tool vehicles (generic full-tool spawning does not count), read-only research stays in the orchestrator's own context, never a vehicle mandate a host cannot satisfy. Judgment, code, synthesis stay at the frontier lane (a task that genuinely runs/writes keeps a full-tool subagent); honest limit: no deterministic gate classifies a dispatch — canon at the point of use + placed vehicles + the retro loop. **Writer economy:** a stage's repeated WRITER commands batch — evidence declarations ride consecutive plain invocations of ONE allow-listed tool, other stage writers combine via one launcher per stage; never an unbatched writer scatter (each gated write is its own prompt).
 
 ### 2.7. Story sessions
-A story — one row of an epic's ledger, carried by one plan — runs as five sessions, each ending at its own review checkpoint: **spec** (the contract under `docs/ai/specs/`, drafted and reviewed on the `plan-authoring` recipe), **plan** (the ledger, same recipe), **tests** (one task per ledger row, red first), **code** (one task per row, to green), and **diff review, release and record** (the review of the staged tree on the `plan-execution` recipe, the release where the story ships one, then the changelog and handover entries and the plan's Phase: Cleanup). Tests and code never share a session, and a spec and its plan never share one either. A storyless plan runs the same five. **Exception — a split:** moving code and its existing cases into modules, with no new logic and no new case, is one session: a short spec (the Module list), the split, the diff review, the release, Cleanup.
+A story — one row of an epic's ledger, carried by one plan — runs as five sessions, each ending at its own review checkpoint: **spec** (the contract under `docs/ai/specs/`, drafted and reviewed on the `plan-authoring` recipe), **plan** (the ledger, same recipe), **tests** (one task per ledger row, red first), **code** (one task per row, to green), and **diff review, release and record** (the review of the staged tree on the `plan-execution` recipe, the release where the story ships one, then the changelog and handover entries and the plan's Phase: Cleanup). Tests and code never share a session, and a spec and its plan never share one either. A storyless plan runs the same five. **Exception — a split:** moving code and its existing cases into modules, with no new logic and no new case, is one session: a short spec (the Module list), the split, the diff review, the release, Cleanup. Inside the tests and code sessions it is one task per session: each task runs as its own carrier session — one brief, one run, never one run for a whole wave — and the orchestrator's session briefs, checks, verifies and folds.
 
 ---
 

package/references/templates/changelog.md

@@ -17,6 +17,7 @@ maxLines: 700
 ## {{DATE}} — Bootstrap
 
 **Goal:** Initialise the AI-agent memory system.
+**For the user:** what was done, and for what — the project now has an AI-agent memory, so each session starts from the last one's record; what is next, and why — the first real task, whose entry says what it did for you.
 **Changes:**
 - Created `AGENTS.md` (entry point) + `CLAUDE.md` symlink.
 - Created `docs/ai/` with the spec files + `pages/`.

package/references/templates/handover.md

@@ -16,6 +16,14 @@ maxLines: 80
 **Branch:** {{BRANCH}}
 **Active recipes:** not recorded yet — paste the configured-recipe line (composed from `docs/ai/orchestration.json`) and refresh it whenever the config changes.
 
+## For the user
+
+**What was done, and for what:**
+- Bootstrap — the project now has an AI-agent memory, so each session starts from what the last one left.
+
+**What is next, and why:**
+- The first real task — its close replaces these two lines with what it did for you and what comes next.
+
 ## What was done last session
 
 - Bootstrap — AI-agent memory system initialised.

package/tools/profile-gaps.mjs

@@ -1,6 +1,7 @@
 import { resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { CANDIDATE_STATES, isDeployed, judgeCheckerGates } from './checker-gates-read.mjs';
+import { normalizeLensBody, reconcileCommsText, reconcileStoryText } from './lens-region.mjs';
 import { CONFIG_REL, validateConfig } from './orchestration-config.mjs';
 import { TIER_TARGETS } from './reference-profile.mjs';
 import {
@@ -18,6 +19,14 @@ const SLOTS_ID = 'epic-task-slots';
 const STORE_ID = 'epic-store-seeded';
 const STORE_PATH = 'docs/ai/epics';
 const CHECKER_GATES_ID = 'checker-gates-declared';
+const SESSION_RULES_ID = 'session-close-rules';
+const QUEUE_SEED_ID = 'named-queue-row-seed';
+const PLANS_PATH = 'docs/plans';
+const QUEUE_PATH = 'docs/plans/queue.md';
+const QUEUE_SEED_PATH = fileURLToPath(new URL('../references/authoring/QUEUE_TEMPLATE.md', import.meta.url));
+const ABSENT_ARM_CODES = new Set(['ENOENT', 'ENOTDIR']);
+const CURRENT_STATUS = 'current';
+const REFRESHED_STATUS = 'refreshed';
 const TIER_PREVIEW_PATH = fileURLToPath(new URL('./tier-preview.mjs', import.meta.url));
 const CHECKER_GATES_PATH = fileURLToPath(new URL('./checker-gates.mjs', import.meta.url));
 const UNDECIDED_STATES = [CANDIDATE_STATES.idTaken, CANDIDATE_STATES.probeUnreadable, CANDIDATE_STATES.withheld];
@@ -47,7 +56,19 @@ const REASONS = Object.freeze({
   storeNotDirectory: 'store-not-directory',
   storeSymlink: 'store-symlink',
   storeUnreadable: 'store-unreadable',
+  headingTwice: 'heading-twice',
+  regionPrior: 'region-prior',
+  regionCustomized: 'region-customized',
+  plansSymlink: 'plans-symlink',
+  plansNotDirectory: 'plans-not-directory',
+  plansUnreadable: 'plans-unreadable',
+  queueSymlink: 'queue-symlink',
+  queueNotRegular: 'queue-not-regular',
+  queueUnreadable: 'queue-unreadable',
+  seedUnreadable: 'seed-unreadable',
 });
+const REGION_ABSENT = Object.freeze({ communication: 'communication-absent', 'story-sessions': 'story-sessions-absent' });
+const JUDGEMENTS = Object.freeze({ communication: reconcileCommsText, 'story-sessions': reconcileStoryText });
 const TEMPLATE_REGIONS = RULES_REGIONS.filter(({ canon }) => canon === TEMPLATE_CANON);
 const STORY_REGION = RULES_REGIONS.find(({ id }) => id === STORY_ID);
 
@@ -162,6 +183,63 @@ const detectCheckerGates = ({ root, deps }) => {
   return undecided ? reportUndecidable(undecided.state) : { verdict: VERDICTS.present };
 };
 
+// A region is judged by the reconcile's own pure judgement, so this entry and the lens step agree.
+const judgeRegion = (text, spans, { id, headingRe, priors }) => {
+  if (!extractRegionBy(text, headingRe).found) return REGION_ABSENT[id];
+  const { status } = JUDGEMENTS[id](text, normalizeLensBody(spans[id].span), priors);
+  if (status === CURRENT_STATUS) return null;
+  return status === REFRESHED_STATUS ? REASONS.regionPrior : REASONS.regionCustomized;
+};
+
+const detectSessionRules = ({ root, deps }) => {
+  const template = readSpans(deps);
+  if (template.verdict) return template;
+  const target = readTarget(root, deps);
+  if (target.verdict) return target;
+  const { text } = target;
+  if (TEMPLATE_REGIONS.some(({ headingRe }) => extractRegionBy(text, headingRe).count > SINGLE_HEADING)) {
+    return reportUndecidable(REASONS.headingTwice);
+  }
+  for (const region of TEMPLATE_REGIONS) {
+    const reason = judgeRegion(text, template.spans, region);
+    if (reason) return reportUndecidable(reason);
+  }
+  return { verdict: VERDICTS.present };
+};
+
+export const readQueueSeed = (deps) => {
+  try {
+    return { bytes: deps.readFileSync(QUEUE_SEED_PATH) };
+  } catch {
+    return { reason: REASONS.seedUnreadable };
+  }
+};
+
+const absentUnlessSeedUnreadable = (deps) => {
+  const seed = readQueueSeed(deps);
+  return seed.reason ? reportUndecidable(seed.reason) : { verdict: VERDICTS.absent };
+};
+
+const detectQueueSeed = ({ root, deps }) => {
+  if (!isDeployed(root, deps)) return reportUndecidable(REASONS.noDeployment);
+  let plans;
+  try {
+    plans = deps.lstatSync(resolve(root, PLANS_PATH));
+  } catch (error) {
+    return ABSENT_ARM_CODES.has(error?.code) ? absentUnlessSeedUnreadable(deps) : reportUndecidable(REASONS.plansUnreadable);
+  }
+  if (plans.isSymbolicLink()) return reportUndecidable(REASONS.plansSymlink);
+  if (!plans.isDirectory()) return reportUndecidable(REASONS.plansNotDirectory);
+  let queue;
+  try {
+    queue = deps.lstatSync(resolve(root, QUEUE_PATH));
+  } catch (error) {
+    return error?.code === MISSING_FILE_CODE ? absentUnlessSeedUnreadable(deps) : reportUndecidable(REASONS.queueUnreadable);
+  }
+  if (queue.isSymbolicLink()) return reportUndecidable(REASONS.queueSymlink);
+  return queue.isFile() ? { verdict: VERDICTS.present } : reportUndecidable(REASONS.queueNotRegular);
+};
+
 const tierPreview = (root) => buildInsertPreview(root, TIER_PREVIEW_PATH);
 
 export const PROFILE_GAPS = Object.freeze([
@@ -169,4 +247,6 @@ export const PROFILE_GAPS = Object.freeze([
   Object.freeze({ id: SLOTS_ID, detect: detectSlots, apply: tierPreview }),
   Object.freeze({ id: STORE_ID, detect: detectStore, apply: tierPreview }),
   Object.freeze({ id: CHECKER_GATES_ID, detect: detectCheckerGates, apply: (root) => buildInsertPreview(root, CHECKER_GATES_PATH) }),
+  Object.freeze({ id: SESSION_RULES_ID, detect: detectSessionRules, apply: (root) => buildInsertPreview(root) }),
+  Object.freeze({ id: QUEUE_SEED_ID, detect: detectQueueSeed, apply: tierPreview }),
 ]);

package/tools/rules-regions.mjs

@@ -27,7 +27,7 @@ const SINGLE_QUOTE = "'";
 const QUOTE_ESCAPE = "'\\''";
 
 // Append the OUTGOING canon here in the same release that changes the template
-// §2.5 region — the fragment-or-prior reconcile depends on it.
+// §2.5 or §2.7 region — the fragment-or-prior reconcile depends on it.
 const COMMS_PRIOR_PRE_AD054 = `### 2.x. Communication (user-facing messages)
 Apply this as part of §2 before any user-facing summary:
 - **Deliver the artifact IN the message** — paste the prompt / diff / version / command inline; never "see §X / open the file / run it and you'll see" as a *substitute* for showing what was asked.
@@ -46,7 +46,13 @@ Apply this as part of §2 before any user-facing summary:
 - **Live host/session facts are tool-composed only.** Any claim about the current host or session state (prompts fired, sandbox scope, whether a bypass was needed, network reachability, approval counts) must trace to **live tool output** from **this session**; a memory/handover snapshot is **context, never report facts**, and a claim with no live signal is **omitted or explicitly marked unverified** — never asserted from recollection.`;
 const COMMS_PRIOR_STATE_BLOCK = `${COMMS_PRIOR_PLAIN_LANGUAGE}
 - **The closing state block answers three DIFFERENT questions.** Close a user-facing message with three labelled slots — *now* · *what I need from you* · *what's next*. The slot LABELS stay ENGLISH — an English label is what lets a state-block checker FIND the block and its slots at all; everything written INTO a slot is in the project's dialogue language; when that language is not English, the checker's English phrase sets do not judge those values. **Now** = the state at this instant: what is RUNNING, or what the work is stopped on. It is **never a report of finished work** — what you completed goes in the message BODY, above the block. **From you** = the real unblocker, named; a turn that is ENDING always has one. **Next** = what follows. A *now* slot that opens with what was completed buries the one fact the reader opened the message for, and the three slots collapse into one restatement.`;
-const COMMS_PRIORS = [COMMS_PRIOR_PRE_AD054, COMMS_PRIOR_AD054, COMMS_PRIOR_PLAIN_LANGUAGE, COMMS_PRIOR_STATE_BLOCK];
+const COMMS_PRIOR_SKIP_FINDING = `${COMMS_PRIOR_STATE_BLOCK}
+- **A skip that contradicts the tree is a finding.** A tool-composed \`skipped-*\` line whose stated reason the observed tree disproves (a "no Node" skip beside deployed Node scripts) is raised as a FINDING in the report, never pasted as a neutral outcome — and a tool may not emit a skip whose reason it could itself disprove.`;
+const COMMS_PRIORS = [
+  COMMS_PRIOR_PRE_AD054, COMMS_PRIOR_AD054, COMMS_PRIOR_PLAIN_LANGUAGE, COMMS_PRIOR_STATE_BLOCK, COMMS_PRIOR_SKIP_FINDING,
+];
+const STORY_PRIOR_FIVE_SESSIONS = `### 2.x. Story sessions
+A story — one row of an epic's ledger, carried by one plan — runs as five sessions, each ending at its own review checkpoint: **spec** (the contract under \`docs/ai/specs/\`, drafted and reviewed on the \`plan-authoring\` recipe), **plan** (the ledger, same recipe), **tests** (one task per ledger row, red first), **code** (one task per row, to green), and **diff review, release and record** (the review of the staged tree on the \`plan-execution\` recipe, the release where the story ships one, then the changelog and handover entries and the plan's Phase: Cleanup). Tests and code never share a session, and a spec and its plan never share one either. A storyless plan runs the same five. **Exception — a split:** moving code and its existing cases into modules, with no new logic and no new case, is one session: a short spec (the Module list), the split, the diff review, the release, Cleanup.`;
 
 export const RULES_REGIONS = Object.freeze([
   Object.freeze({
@@ -61,7 +67,7 @@ export const RULES_REGIONS = Object.freeze([
     headingRe: /^### 2[.]([0-9]+)[.] Story sessions/,
     label: '### 2.x. Story sessions',
     canon: TEMPLATE_CANON,
-    priors: [],
+    priors: [STORY_PRIOR_FIVE_SESSIONS],
   }),
   Object.freeze({
     id: 'lens',

package/tools/session-close-check.mjs

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+// session-close-check.mjs — the read-only checker of a session close: judges the `## For the user`
+// section of docs/ai/handover.md and its two labels. Governing contract:
+// docs/ai/specs/kit/tier/session-rules/ (part session-close-check). Not a gate: a session close is
+// not a commit boundary. main(argv, deps) returns, never exits, never asks; every read goes through deps.
+import { resolve } from 'node:path';
+import { safeLine } from './carriers.mjs';
+import { isDeployed } from './checker-gates-read.mjs';
+import { isDirectRun } from './direct-run.mjs';
+import { readRegularFileNoFollow } from './fs-read-nofollow.mjs';
+
+const LF = String.fromCharCode(10);
+const CR = String.fromCharCode(13);
+const BOM_CHAR = String.fromCharCode(65279);
+const ARGV_OFFSET = 2;
+const EXIT_ACCEPT = 0;
+const EXIT_REFUSAL = 1;
+const EXIT_CANNOT_JUDGE = 2;
+const CHECK_FLAG = '--check';
+const CWD_FLAG = '--cwd';
+const HELP_FLAG = '--help';
+const HANDOVER_REL = 'docs/ai/handover.md';
+const SECTION_HEADING = '## For the user';
+const SECTION_BOUNDARY = '## ';
+const LABELS = Object.freeze(['**What was done, and for what:**', '**What is next, and why:**']);
+const SINGLE = 1;
+const SYMLINK_CLASS = 'symlink';
+
+const STATES = Object.freeze({
+  noDeployment: 'no-deployment',
+  handoverSymlink: 'handover-symlink',
+  handoverNotRegular: 'handover-not-regular',
+  handoverUnreadable: 'handover-unreadable',
+  handoverAbsent: 'handover-absent',
+  sectionAbsent: 'section-absent',
+  sectionTwice: 'section-twice',
+  labelAbsent: 'label-absent',
+  labelTwice: 'label-twice',
+  labelOrder: 'label-order',
+  labelEmpty: 'label-empty',
+});
+
+export const OUTCOME_LINES = Object.freeze({
+  accept: () => 'session-close-check: accept — the handover carries the For the user section with both labels and their text',
+  state: (name) => safeLine(name),
+  labelState: (name, label) => `${safeLine(name)}: ${safeLine(label)}`,
+  usage: (problem) => `usage: session-close-check.mjs --check [--cwd DIR] — ${safeLine(problem)}`,
+  help: () => [
+    'session-close-check.mjs --check [--cwd DIR]',
+    'Judges the For the user section of docs/ai/handover.md in DIR (default: the current directory); writes nothing.',
+    'Exit codes: 0 accept, 1 one refusal per line, 2 usage or cannot judge.',
+  ].join(LF),
+});
+
+const result = (code, stdout = '', stderr = '') => ({ code, stdout, stderr });
+const cannotJudge = (name) => result(EXIT_CANNOT_JUDGE, '', OUTCOME_LINES.state(name));
+
+const parseArgs = (argv) => {
+  if (argv.length === 1 && argv[0] === HELP_FLAG) return { help: true };
+  const options = {};
+  for (let index = 0; index < argv.length; index += 1) {
+    const flag = argv[index];
+    if (flag === HELP_FLAG) return { problem: `${HELP_FLAG} takes no other argument` };
+    if (flag === CHECK_FLAG) {
+      if (options.check) return { problem: `${CHECK_FLAG} given twice` };
+      options.check = true;
+    } else if (flag === CWD_FLAG) {
+      if (options.cwd !== undefined) return { problem: `${CWD_FLAG} given twice` };
+      const value = argv[index + 1];
+      if (value === undefined || value.startsWith('-')) return { problem: `${CWD_FLAG} needs a directory` };
+      options.cwd = value;
+      index += 1;
+    } else {
+      return { problem: `unknown argument ${flag}` };
+    }
+  }
+  if (!options.check) return { problem: `${CHECK_FLAG} is required` };
+  return { cwd: options.cwd ?? '.' };
+};
+
+const stripCr = (line) => (line.endsWith(CR) ? line.slice(0, -1) : line);
+const isBlank = (text) => text.trim() === '';
+
+const sectionLines = (text) => {
+  const lines = text.split(LF).map(stripCr);
+  if (lines[0].startsWith(BOM_CHAR)) lines[0] = lines[0].slice(BOM_CHAR.length);
+  const starts = lines.flatMap((line, index) => (line === SECTION_HEADING ? [index] : []));
+  if (starts.length !== SINGLE) return { state: starts.length === 0 ? STATES.sectionAbsent : STATES.sectionTwice };
+  const body = lines.slice(starts[0] + 1);
+  const end = body.findIndex((line) => line.startsWith(SECTION_BOUNDARY));
+  return { lines: end === -1 ? body : body.slice(0, end) };
+};
+
+const isLabelLine = (line) => LABELS.some((label) => line.startsWith(label));
+
+const hasText = (lines, index, label) => {
+  if (!isBlank(lines[index].slice(label.length))) return true;
+  const after = lines.slice(index + 1);
+  const next = after.findIndex(isLabelLine);
+  return (next === -1 ? after : after.slice(0, next)).some((line) => !isBlank(line));
+};
+
+const judgeLabels = (lines) => {
+  const found = LABELS.map((label) => ({
+    label,
+    at: lines.flatMap((line, index) => (line.startsWith(label) ? [index] : [])),
+  }));
+  const once = found.filter(({ at }) => at.length === SINGLE);
+  const refusals = [
+    ...found.filter(({ at }) => at.length === 0).map(({ label }) => OUTCOME_LINES.labelState(STATES.labelAbsent, label)),
+    ...found.filter(({ at }) => at.length > SINGLE).map(({ label }) => OUTCOME_LINES.labelState(STATES.labelTwice, label)),
+  ];
+  if (once.length === LABELS.length && once[1].at[0] < once[0].at[0]) refusals.push(OUTCOME_LINES.state(STATES.labelOrder));
+  for (const { label, at } of once) {
+    if (!hasText(lines, at[0], label)) refusals.push(OUTCOME_LINES.labelState(STATES.labelEmpty, label));
+  }
+  return refusals;
+};
+
+const judgeHandover = (content) => {
+  const section = sectionLines(content);
+  if (section.state) return [OUTCOME_LINES.state(section.state)];
+  return judgeLabels(section.lines);
+};
+
+const runCheck = (options, deps) => {
+  const root = resolve(options.cwd);
+  if (!isDeployed(root, deps)) return cannotJudge(STATES.noDeployment);
+  const read = readRegularFileNoFollow(resolve(root, HANDOVER_REL), deps);
+  if (read.outcome === 'absent') return result(EXIT_REFUSAL, '', OUTCOME_LINES.state(STATES.handoverAbsent));
+  if (read.outcome === 'foreign') {
+    return cannotJudge(read.className === SYMLINK_CLASS ? STATES.handoverSymlink : STATES.handoverNotRegular);
+  }
+  if (read.outcome !== 'ok') return cannotJudge(STATES.handoverUnreadable);
+  const refusals = judgeHandover(read.content);
+  if (refusals.length > 0) return result(EXIT_REFUSAL, '', refusals.join(LF));
+  return result(EXIT_ACCEPT, OUTCOME_LINES.accept());
+};
+
+export const main = (argv, deps = {}) => {
+  const parsed = parseArgs(argv);
+  if (parsed.help) return result(EXIT_ACCEPT, OUTCOME_LINES.help());
+  if (parsed.problem) return result(EXIT_CANNOT_JUDGE, '', OUTCOME_LINES.usage(parsed.problem));
+  return runCheck(parsed, deps);
+};
+
+if (isDirectRun(import.meta.url)) {
+  const outcome = main(process.argv.slice(ARGV_OFFSET));
+  if (outcome.stdout) console.log(outcome.stdout);
+  if (outcome.stderr) console.error(outcome.stderr);
+  process.exitCode = outcome.code;
+}

package/tools/tier-preview.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 // tier-preview.mjs — the offer of lineage step 4.0.0: one preview over the whole profile-gap
-// registry; on an explicit yes (--apply) the absent epic and task slots and the epic store seed;
+// registry; on an explicit yes (--apply) the absent epic and task slots, the epic store seed and the queue seed;
 // on an explicit no (--decline) the decline record. Governing contract:
 // docs/ai/specs/kit/tier/tier-offer/ (part tier-preview). main(argv, deps) returns, never exits,
 // never asks; every read and write goes through deps.
@@ -12,7 +12,7 @@ import { isDirectRun } from './direct-run.mjs';
 import { tmpNote } from './ensure-ops.mjs';
 import { CANON_README, applySetOps, refreshReadme } from './orchestration-config.mjs';
 import { writeConfig } from './orchestration-write.mjs';
-import { PROFILE_GAPS, readTierConfig } from './profile-gaps.mjs';
+import { PROFILE_GAPS, readQueueSeed, readTierConfig } from './profile-gaps.mjs';
 import { composeReadiness, planRecipe } from './recipes.mjs';
 import { TIER_TARGETS, isDeclineCurrent, readDeclines, readShippedProfile } from './reference-profile.mjs';
 
@@ -30,6 +30,10 @@ const SLOTS_ID = 'epic-task-slots';
 const STORE_ID = 'epic-store-seeded';
 const STORE_DIR = 'docs/ai/epics';
 const STORE_SEED = 'docs/ai/epics/.gitkeep';
+const QUEUE_ID = 'named-queue-row-seed';
+const PLANS_DIR = 'docs/plans';
+const QUEUE_SEED = 'docs/plans/queue.md';
+const MISSING_CODE = 'ENOENT';
 const CONFIG_WRITTEN = 'docs/ai/orchestration.json';
 const DECLINES_REL = 'docs/ai/profile-declines.json';
 const SCHEMA = 1;
@@ -53,7 +57,7 @@ export const OUTCOME_LINES = Object.freeze({
   slotValue: (activity, slot, value, skipped = []) => `${INDENT}${activity}.${slot} = ${value}`
     + skipped.map(({ candidate, reason }) => ` — ${candidate} skipped: ${reason}`).join(''),
   slotPresent: (activity, slot) => `${INDENT}${activity}.${slot}: present`,
-  tmpLeft: (tmp) => tmpNote(STORE_SEED, tmp)[0],
+  tmpLeft: (rel, tmp) => tmpNote(rel, tmp)[0],
   nothingOffered: () => 'nothing offered — nothing recorded',
   detectFailed: (cause) => `backend detection failed (${safeLine(cause)}) — every bridge is treated as not ready`,
   refusal: (name, detail) => `tier-preview: refused — ${name}${detail ? `: ${safeLine(detail)}` : ''}`,
@@ -61,7 +65,7 @@ export const OUTCOME_LINES = Object.freeze({
   help: () => [
     'tier-preview.mjs --cwd DIR [--apply | --decline]',
     'Previews every profile gap of the project in DIR; writes nothing by default.',
-    '--apply writes the offered items: the absent epic and task settings and the epic store seed.',
+    '--apply writes the offered items: the absent epic and task settings, the epic store seed and the queue seed.',
     '--decline records every offered item as declined at the shipped profile lineage.',
     'Exit codes: 0 done, 1 one named refusal, 2 usage.',
   ].join(LF),
@@ -149,18 +153,39 @@ const writeSlots = (root, config, slots, deps) => {
   writeConfig(root, refreshReadme(merged).config, deps);
 };
 
-const storeCreated = (root, deps) => {
+const directoryAt = (root, rel, deps) => {
   try {
-    return deps.lstat(resolve(root, STORE_DIR)).isDirectory();
+    return deps.lstat(resolve(root, rel)).isDirectory();
   } catch {
     return false;
   }
 };
 
+const missingAt = (root, rel, deps) => {
+  try {
+    deps.lstat(resolve(root, rel));
+    return false;
+  } catch (error) {
+    return error?.code === MISSING_CODE;
+  }
+};
+
+const writeQueueSeed = (root, deps, bytes, made) => {
+  const plansMissing = missingAt(root, PLANS_DIR, deps);
+  try {
+    return { seeded: writeProjectFileCreateOnly(root, QUEUE_SEED, bytes, deps, { noun: 'the queue seed' }) };
+  } catch (error) {
+    if (plansMissing && directoryAt(root, PLANS_DIR, deps)) made.push(`${PLANS_DIR} created`);
+    return { refusal: refuse('write-failed', [...made, causeOf(error)].join('; ')) };
+  }
+};
+
 const runApply = (root, deps, judged, slots, config) => {
   const byId = new Map(judged.map((item) => [item.entry.id, item]));
   const extra = [];
   const made = [];
+  const seed = byId.get(QUEUE_ID)?.word === WORDS.offered ? readQueueSeed(deps) : null;
+  if (seed?.reason) return { refusal: refuse(seed.reason) };
   if (byId.get(SLOTS_ID)?.word === WORDS.offered) {
     try {
       writeSlots(root, config, slots, deps);
@@ -175,11 +200,21 @@ const runApply = (root, deps, judged, slots, config) => {
     try {
       seeded = writeProjectFileCreateOnly(root, STORE_SEED, '', deps, { noun: 'the epic store seed' });
     } catch (error) {
-      if (storeCreated(root, deps)) made.push(`${STORE_DIR} created`);
+      if (directoryAt(root, STORE_DIR, deps)) made.push(`${STORE_DIR} created`);
       return { refusal: refuse('write-failed', [...made, causeOf(error)].join('; ')) };
     }
     byId.set(STORE_ID, { ...byId.get(STORE_ID), word: seeded.created ? WORDS.applied : WORDS.present });
-    if (seeded.tmpLeftBehind) extra.push(OUTCOME_LINES.tmpLeft(seeded.tmpLeftBehind));
+    if (seeded.created) made.push(`${STORE_SEED} created`);
+    if (seeded.tmpLeftBehind) {
+      extra.push(OUTCOME_LINES.tmpLeft(STORE_SEED, seeded.tmpLeftBehind));
+      made.push(`${seeded.tmpLeftBehind} left behind`);
+    }
+  }
+  if (seed) {
+    const written = writeQueueSeed(root, deps, seed.bytes, made);
+    if (written.refusal) return written;
+    byId.set(QUEUE_ID, { ...byId.get(QUEUE_ID), word: written.seeded.created ? WORDS.applied : WORDS.present });
+    if (written.seeded.tmpLeftBehind) extra.push(OUTCOME_LINES.tmpLeft(QUEUE_SEED, written.seeded.tmpLeftBehind));
   }
   return { judged: judged.map((item) => byId.get(item.entry.id)), extra };
 };