gamma

name	gamma
description	γ role in CDD. Coordination + closure + triage. γ produces dispatch prompts, unblocks via artifact facts, runs post-release assessment, triages findings, and declares cycle closure. δ executes dispatch; harness owns the mechanics.
artifact_class	skill
kata_surface	embedded
governing_question	How does γ keep the full cycle coherent across issue creation, dispatch coordination, unblocking, assessment, and close-out — without leaking into runtime supervision mechanics?
visibility	internal
parent	cdd
triggers	["gamma"]
scope	role-local
inputs	["repo state","lag and signals","issue state","branch state",".cdd/unreleased/{N}/self-coherence.md (α's gap, mode, ACs, CDD Trace, review-readiness, fix-rounds)",".cdd/unreleased/{N}/beta-review.md (β's round-by-round verdicts + findings)",".cdd/unreleased/{N}/alpha-closeout.md (α close-out, post-merge)",".cdd/unreleased/{N}/beta-closeout.md (β close-out + release evidence, post-merge)","release state","delta gate results (observable via git: tags, branch state)"]
outputs	["issue pack","dispatch prompts","unblock decisions (clarification artifacts)","post-release assessment","close-out triage table","cycle closure declaration (gamma-closeout.md)"]
requires	["active role is γ","canonical CDD.md loaded"]
calls	["issue/SKILL.md","post-release/SKILL.md","operator/SKILL.md","harness/SKILL.md","release-effector/SKILL.md"]

Gamma

Core Principle

Coherent γ coordination selects the highest-leverage real gap, turns it into an executable issue pack, preserves role separation during handoffs, and closes the cycle with an explicit next move.

γ is not a third implementer and not a runtime orchestrator. γ holds cycle coherence: selection, issue quality, dispatch-prompt quality, unblocking, close-out triage, and process iteration. γ produces α and β prompts; δ (operator) executes dispatch via the harness — one role at a time. This avoids nested subprocess chains (γ spawning α/β), keeps memory pressure low, and gives δ direct visibility into each session.

The failure mode is orchestration by vibes: arbitrary selection, vague issues, prompts that compensate for underspecified skills, leaked α/β reasoning across the boundary, cycle closure without learning. The related failure is managerial residue — verbs like monitor / track / supervise that produce no artifact, receipt, or boundary decision. The sweep rule (COHERENCE-CELL.md §γ and δ Managerial-Residue Sweep) is binding: any γ verb that produces no concrete output is suspect; rename to the actual biological function or relocate to the substrate.

Load Order

When acting as γ:

1. Load CDD.md — canonical lifecycle, selection rules, role contract.
2. Load this file — the γ role surface (coordination + closure + triage).
3. Load issue/SKILL.md — issue-pack contract.
4. Load post-release/SKILL.md — γ owns the PRA (cycle-level assessment of α, β, cycle economics) and step 13a skill/spec patches.
5. Load operator/SKILL.md — δ-role policy frame. harness/SKILL.md owns dispatch mechanics (invocation shell, observability, worktree, identity, polling, timeout recovery); release-effector/SKILL.md owns release mechanics (scripts/release.sh, post-push CI polling, CI-red recovery, branch deletes). γ references these when authoring prompts that name observable-output flags or when requesting gate actions.
6. Load other lifecycle sub-skills only when the selected gap requires them.

Canonical-skill staleness check before each γ phase change. Before transitioning from one CDD phase to another (intake → dispatch, dispatch → close-out triage, close-out triage → PRA, PRA → closure), γ runs git fetch --verbose origin main && git rev-parse origin/main. If origin/main HEAD has advanced beyond the SHA at which canonical CDD/role skills were loaded, re-load CDD.md, this file, and the lifecycle sub-skill governing the next phase, then re-evaluate the next phase's plan against the updated canonical surfaces. This is the parallel of beta/SKILL.md's pre-merge gate row 2 on the γ-axis; it catches canonical-skill snapshot drift across release boundaries (cycle #301 §9.1 trigger 1: γ proposed an out-of-spec merge option because σ's 4a0f678 "merge is β authority" had landed mid-cycle and was not in γ's session-loaded gamma/SKILL.md).

Canonical artifact locations (PRA, close-out paths, snapshot dirs, tag policy) are defined in cnos.cds/skills/cds/CDS.md §"Artifact contract" → §"Location matrix".

cnos.cds/skills/cds/CDS.md is the canonical source for: the ordered γ lifecycle (§"Development lifecycle" → §"Step table" — γ owns Steps 0–3 and Steps 9–13; Step 8 is β's; Steps 9–10 are δ's release-gate authority; Step 10's tag mechanics are δ's via release-effector/SKILL.md) and selection rule order (§"Selection function"). This file does not redefine that algorithm — it expands those steps into executable checks, evidence, and gates.

Step map

• Step 1 → git identity (harness/SKILL.md §3), Step 2a → observe + candidates (§2.1), Step 2b → select + size (§2.2)
• Step 3 → issue pack + quality gate (§2.3–§2.4)
• Step 3a → create cycle branch (§2.5 — cycle/{N} from origin/main, γ-owned pre-flight per cnos.cds/skills/cds/CDS.md §"Development lifecycle" → §"Branch pre-flight")
• Steps 3b–6 → dispatch + unblocking (§2.5)
• Steps 7–8 → release-prep artifacts (§2.6)
• Steps 9–10 → close-out triage (§2.7)
• Steps 11–13 → cycle iteration + process patching (§2.8–§2.9)
• Steps 14–16 → hub memory, branch cleanup, closure declaration (§2.10)
• Step 17 → δ disconnect release (mechanics: release-effector/SKILL.md; doctrinal frame: delta/SKILL.md §1) — not γ's

---

1. Define

Parts of a coherent γ cycle: observation inputs / candidate table / selected gap / issue pack / dispatch prompts / unblock actions (clarification artifacts) / close-out findings / next-move commitment. Observation produces candidates; selection chooses one by rule, not taste; the issue pack makes the work executable; dispatch preserves separation; unblocking restores flow without collapsing roles; close-out converts findings into immediate fixes or committed next work.

Failure modes. γ fails through:

• selection drift — choosing by excitement instead of CDD rule order

• issue ambiguity — α must ask for missing constraints, ACs, or skills

• prompt compensation — dispatch prompt grows because the issue or skill is weak

• role leakage — α sees β reasoning state or β sees α rationale state

• closure amnesia — findings noted but not triaged into patch / issue / drop

• managerial residue — verbs without concrete output (track, monitor, supervise) leaking from substrate into γ doctrine

• ❌ "γ just creates issues and nudges people"

• ✅ "γ owns the decision and artifact quality that make α/β work coherent"

---

2. Unfold

2.1. Step 1a — Observe and build candidates

Read the observation surfaces required by CDD.md:

1. Last post-release assessment (read first) — prior cycle's next-MCA commitment, deferred outputs, cycle iteration findings, MCI freeze state. Binding, not optional.
2. CHANGELOG TSC table.
3. Encoding lag table.
4. Doctor / status / operational-health surface.
5. Cross-repo proposal intake — scan .cdd/iterations/cross-repo/cnos/*/STATUS for the last non-comment event = submitted (or drafted with source-delegated filing-authority per cnos.handoff/skills/handoff/cross-repo/SKILL.md §2.3.3). For each candidate, read the adjacent ISSUE.md + optional PATCH.diff, check cnos target state for duplicate / already-landed work, decide accepted / modified / rejected, file a target issue with the ## Source Proposal block from cdd/issue/SKILL.md, and emit the disposition event to source STATUS. Protocol details (8-event vocabulary, transition graph, bundle file set, LINEAGE schema, feedback-patch format) live in cnos.handoff/skills/handoff/cross-repo/SKILL.md.

Build a candidate table:

| Candidate | Source | Rule clause that nominates it             | Dependency | Size | Decision |
|-----------|--------|-------------------------------------------|------------|------|----------|
| #NN ...   | lag    | CDS §Selection function → §X              | ...        | ...  | ...      |

• ❌ "I remember issue #143 felt important"
• ✅ "Candidate table shows #143 is selected under cnos.cds/skills/cds/CDS.md §"Selection function" §X.x for a named reason"

2.2. Step 1b — Select by CDS §Selection function, then size the intervention

Apply cnos.cds/skills/cds/CDS.md §"Selection function" in order (P0 override → operational-infrastructure override → assessment-commitment default → stale-backlog re-evaluation → MCI freeze check → weakest-axis rule → maximum-leverage rule → dependency order → effort-adjusted tie-break → no-gap case). Required output: selected gap / decisive cnos.cds/skills/cds/CDS.md §"Selection function" rule-clause / rejected alternatives when non-obvious / intervention size (immediate output / small change / substantial cycle).

Sizing rule: immediate-output → execute now + continue observation; small-change → route to small-change path; blocked → name the blocking dependency before dispatch.

• ❌ "Selected because it felt highest leverage"
• ✅ "Selected #143 under cnos.cds/skills/cds/CDS.md §"Selection function" → §"Maximum-leverage rule"; #151 rejected because dependency unresolved"

2.2a. Peer enumeration at scaffold time

Before authoring §Gap in self-coherence.md, γ MUST: (1) list every file in directories named by the issue's impact graph (ls -la or find per directory); (2) grep for the term/symbol/surface the cycle proposes to add (rg <term> <directories>); (3) if any match is found, name it explicitly in §Gap — additive framing ("partially closed by X; this cycle completes it") or consolidation framing ("X overlaps the proposed surface; reconcile in scope").

A §Gap that asserts "X does not exist" without grep-evidence is a γ-side honest-claim violation analogous to α's rule 3.13(a).

Empirical anchor — tsc cycle #36: §Gap asserted "CI does not invoke coh --kata against shipped kata content"; .github/workflows/ci.yml's kata-check job (added in 344-c) invoked bash scripts/run-katas.sh which auto-discovers every kata. The negation was empirically false; β R1 caught it as binding finding B-1 (RC). Cost: 1 wasted RC round.

• ❌ "X does not exist" without grep evidence
• ✅ "X does not exist — confirmed by rg X directories/ returning no matches"

2.3. Step 2 — Build the issue pack

Use issue/SKILL.md as the base contract. A dispatchable γ issue is:

• a complete issue/SKILL.md issue
• plus a work-shape note (substantial / small-change / immediate-output)
• plus dependency notes when sequencing or blockers are real

γ does not restate Tier 1 or Tier 2 skills in the issue. γ does name Tier 3 skills, active design constraints, related artifacts, non-goals, and priority exactly as issue/SKILL.md requires.

If the issue cannot be written to that level, the work is not ready for α dispatch.

2.4. Step 2 — Pass the issue-quality gate

Before dispatch, verify:

• issue satisfies issue/SKILL.md
• ACs are numbered and independently testable
• every noun in ACs and work items is in scope
• non-goals exist when the issue is substantial
• Tier 3 skills are named explicitly
• active design constraints are linked and stated plainly
• related artifacts are linked or explicitly absent
• priority is stated
• work-shape is stated
• dependency notes exist when blockers or sequencing are real
• no prompt-only constraints are hiding outside the issue

Do not compensate for a weak issue by making the prompt longer. Fix the issue instead.

2.5. Steps 3a–5 — Create the cycle branch, dispatch, unblock without leakage

Step 3a — Create the cycle branch

After the issue passes the quality gate (§2.4) and before dispatching α/β, γ creates cycle/{N} from origin/main. The branch is the canonical coordination surface (cnos.cds/skills/cds/CDS.md §"Coordination surfaces" + §"Development lifecycle" → §"Branch rule"); a single named target replaces the pre-#287 model where α opened the branch.

γ-owned branch pre-flight (cnos.cds/skills/cds/CDS.md §"Development lifecycle" → §"Branch pre-flight"): origin/cycle/{N} does not yet exist (fail loud — one cycle = one branch); no stalled .cdd/unreleased/{N}/ on origin/main (would indicate a previous cycle for {N} did not complete its release-time move per release/SKILL.md §2.5a); the issue's scope is declared in the body; base SHA known (git rev-parse origin/main); issue is open. Mechanics (the git fetch + rev-parse --verify + ls-tree + switch -c + push -u sequence) follow cnos.cds/skills/cds/CDS.md §"Development lifecycle" → §"Branch pre-flight" directly; γ does not restate them here.

The branch must exist on origin before dispatch. α and β never create branches; their prompts include a Branch: cycle/<N> line and they git switch to it.

Step 3b — Subscribe and dispatch α and β

Pre-dispatch γ scaffold check (binding gate)

Binding rule. γ MUST NOT proceed to α dispatch until .cdd/unreleased/{N}/gamma-scaffold.md exists on origin/cycle/{N}. If absent when γ is about to produce the α prompt, γ authors it first, commits and pushes it to cycle/{N}, then continues.

The scaffold names: issue / mode (substantial / small-change / immediate-output, and §5.2 wave-mode if applicable) / surfaces γ expects α to touch / AC oracle approach / empirical anchor when framed (§2.2a) / expected diff scope. It is the executable rendering of what γ already decided at selection time, not new analysis.

Dual of review/SKILL.md rule 3.11b. When gamma-scaffold.md is missing on the cycle branch at review time and no ## Protocol exemption exists in the sub-issue body, β returns REQUEST CHANGES (D-severity, protocol-compliance). β-side enforcement guarantees the artifact exists by merge time but pays the round-trip per RC round; γ-side pre-dispatch enforcement pays once per cycle at scaffold time. The two gates are symmetric.

Empirical anchor — cycle #369. β R1 fired rule 3.11b as D1 against α's review-ready signal (missing scaffold); γ recovered via path (a) at 227d2373; β R2 APPROVED at 4e179db6; merged at ff54f2a0. All 10 ACs were met at R1 — the one "no" row was the missing scaffold. The γ-side gate makes rule 3.11b's RC the dual-redundant safety net rather than the routine first detector.

Mechanical check (run before producing the α prompt): git ls-tree -r --name-only origin/cycle/<N> .cdd/unreleased/<N>/gamma-scaffold.md must be non-empty; otherwise γ authors the scaffold, commits, pushes, and re-runs.

Protocol exemption. Per review/SKILL.md §3.11b "Exemption discoverability": γ may skip the scaffold only if the sub-issue body carries an explicit ## Protocol exemption section naming the reason (emergency patch, infra-only change with operator override, wave-manifest-as-γ-artifact per operator/SKILL.md §10).

Polling cross-reference

γ polls the issue and origin/cycle/{N} to react to α/β commits, β verdicts, and CI status. Mechanics: harness/SKILL.md §5.4 (single-named-branch transition loop, Monitor-wrapped, reachability re-probe per cnos.cds/skills/cds/CDS.md §"Coordination surfaces" → §"Polling primitives"). γ's invariant: polling requires a query, a wake-up mechanism, and a reachability probe. If the environment provides neither a Monitor-equivalent nor a shell-wake harness, γ surfaces the gap to operator before dispatch. Cycle-dir artifacts live on origin/cycle/{N} (not on main) until release-time move; polling main for in-flight cycle dirs is silent.

Dispatch prompts + implementation contract → cnos.handoff

γ produces the dispatch prompts (γ / α / β) and δ routes them via cn dispatch. γ does not execute dispatch; γ produces prompts. The α prompt MUST carry the 7-axis ## Implementation contract block γ injects per the wire-format template — γ MUST NOT dispatch with empty / "TBD" rows.

Canonical wire format lives at cnos.handoff/skills/handoff/dispatch/SKILL.md (Sub 3 of cnos#404, shipped under cnos#417). That skill owns the γ / α / β prompt templates, the 7-axis implementation-contract schema (Language; CLI integration target; Package scoping; Existing-binary disposition; Runtime dependencies; JSON/wire contract preservation; Backward-compat invariant), the prompt rules (issue reference shape, explicit Branch: line, --json convention, do-not-restate-the-algorithm, do-not-smuggle-constraints), the δ-as-inward-membrane enrichment doctrine, and the four-surface mesh declaration (γ template ↔ δ enrichment ↔ α constraint ↔ β verification).

γ's role-local obligation here: author the dispatch prompts at the wire-format shape; inject the ## Implementation contract section into the α prompt with every row populated; escalate to δ when a row's value is unclear; log any mid-cycle re-pin in .cdd/unreleased/{N}/gamma-clarification.md before signaling the change. The doctrine lives at handoff; the role-local procedure (γ authors the prompts during scaffold; δ reviews before routing) lives here as cycle-lifecycle coordination.

Tooling and observability flags (--allowedTools, --output-format stream-json --verbose, --permission-mode acceptEdits) live in harness/SKILL.md §1–§2; γ does not restate them here.

Spec-staleness propagation

When γ (or δ) pushes spec changes to origin/main while α/β sessions are in-flight, loaded skills become stale. γ's responsibility:

• Identity-rotation mode (cn dispatch / claude -p): Not applicable — each role invocation loads skills fresh from the filesystem; the next dispatch picks them up.
• Long-lived polling sessions (legacy): γ writes a coordination note to .cdd/unreleased/{N}/gamma-coordination.md on cycle/{N} naming the spec change and affected skill path; or surfaces via the dispatch channel.
• When to propagate: Changes to CDD.md, role skill files (alpha/, beta/, gamma/, operator/, delta/, harness/, release-effector/), release/SKILL.md, or review/SKILL.md landing on main while in-flight.
• When not to propagate: Changes outside the CDD package, doc-only, or issues/threads.

Canonical wire-format home at cnos.handoff/skills/handoff/mid-flight/SKILL.md §2.6 (Sub 4 of cnos#404 / cnos#418). The wire-format invariant ("γ writes a coordination note when spec changes land on origin/main mid-flight; cycle branch is the substrate") lives at cnos.handoff; the consumer-specific file list above (which cdd skill files trigger propagation) is the CDD-side realization.

Derives from #301 §9.1: γ proposed an out-of-spec merge because σ's 4a0f678 ("merge is β authority") landed mid-cycle outside γ's loaded snapshot. The reactive fix is the staleness check in Load Order; this is the proactive side.

Step 5 — Unblock

When α or β is blocked, γ may: clarify requirement wording / add missing artifact links / edit the issue to state an omitted invariant / resolve scope ambiguity / provide mechanical environment help / point the role back to the governing skill or artifact.

γ may not: forward β's reasoning transcript to α / forward α's rationale transcript to β / author the implementation fix inside the review loop / silently change the target gap without updating the issue.

Allowed transfer unit: artifact facts, not hidden role state.

• ❌ "β said this design is shaky; just rewrite the parser like this"
• ✅ "The issue omitted invariant X; γ adds it to the issue and points α back to the updated artifact"

Issue-edit cache-bust procedure. When γ edits an issue body mid-cycle, γ commits a gamma-clarification.md entry on the cycle branch before signaling the edit. The cycle-branch transition is the signal; γ does not need to chat-relay. The clarification names: date, edit summary, and which ACs / non-goals / constraints / artifacts changed. Canonical wire-format home at cnos.handoff/skills/handoff/mid-flight/SKILL.md (Sub 4 of cnos#404 / cnos#418); this section retains the role-local procedure citation.

2.6. Steps 6–7 — Prepare release artifacts before δ tags

In the sequential dispatch model, β exits after merge. δ runs scripts/release.sh per release-effector/SKILL.md (stamp + tag) but does not author artifacts. γ owns two release-preparation steps that must land on main before γ requests the tag from δ:

1. Write RELEASE.md — per release/SKILL.md §2.5. The GitHub release body, at repo root, committed to main. Without it, release CI auto-generates sparse notes.
2. Move cycle directories — per release/SKILL.md §2.5a. Move .cdd/unreleased/{N}/ → .cdd/releases/{X.Y.Z}/{N}/ for every cycle closed in this release. Commit on main before the tag.

Before any push that follows a rebase, run the eng/ship rebase-integrity gate (see eng/ship § Rebase-Collision Integrity).

Both must be committed before γ requests the disconnect release from δ (§2.10 → release-effector/SKILL.md).

• ❌ Leave RELEASE.md for δ to write (δ does not author)
• ❌ Leave unreleased directories for "later" (they lose version association)
• ❌ Assume β handled release prep (β exits at merge in sequential model)
• ✅ γ writes RELEASE.md + moves cycle dirs → commits to main → requests tag from δ

2.7. Steps 8–9 — Triage close-outs explicitly

Collecting close-outs in sequential bounded dispatch (cnos.cds/skills/cds/CDS.md §"Field 6: Actor collapse rule"). β exits after writing beta-closeout.md; α already exited after signaling review-readiness. γ obtains both close-outs before triaging:

1. β close-out: verify .cdd/unreleased/{N}/beta-closeout.md on main; if missing, request δ to re-dispatch β.
2. α close-out: verify .cdd/unreleased/{N}/alpha-closeout.md on main; if missing, request δ to re-dispatch α via the close-out prompt (cnos.cds/skills/cds/CDS.md §"Coordination surfaces"; prompt format in operator/SKILL.md §5.2 v0.1 overlay). γ must explicitly request this re-dispatch.

Cross-repo proposal close-out. If this cycle accepted or modified a source proposal, γ emits the landed event to source STATUS at merge. Per cnos.handoff/skills/handoff/cross-repo/SKILL.md §"STATUS state machine" master/sub rule: per-sub landed per merge, terminal master-close when the master closes. A proposal touched by the cycle may not remain at accepted / modified after target work lands.

Post-merge CI verification (mandatory). Before authoring gamma-closeout.md, γ verifies CI ran green on the merge commit (gh run list --branch main --json status,conclusion,head_sha filtered to merge SHA). Pending → delay close-out. Red → log as §9.1 trigger (avoidable tooling failure); γ-axis grade reflects; consider rollback or follow-on fix-cycle. Green → record run URL in gamma-closeout.md §Post-merge verification.

self-coherence.md + beta-review.md carry the in-cycle record; the two *-closeout.md files are γ's primary triage inputs. The cycle-directory move (.cdd/unreleased/{N}/ → .cdd/releases/{X.Y.Z}/{N}/) is γ's per §2.6 — before the tag, not after (cnos.cds/skills/cds/CDS.md §"Artifact contract" → §"Location matrix").

Then write the post-release assessment per post-release/SKILL.md at docs/{tier}/{bundle}/{X.Y.Z}/POST-RELEASE-ASSESSMENT.md (CDD package: docs/gamma/cdd/{X.Y.Z}/POST-RELEASE-ASSESSMENT.md). The PRA is γ's — it measures α's implementation, β's review quality, and cycle economics. β assessing its own review is a self-grading problem.

γ triages every finding from both close-outs + the PRA using CAP:

1. Immediate MCA available → ship now (γ lands the skill/spec patch per cnos.cds/skills/cds/CDS.md §"Closure" → §"Immediate outputs"; if delegated, name delegate + deadline)
2. Project MCI → file / update project issue or .cdd/ artifact
3. Agent MCI → update hub / adhoc thread
4. One-off → drop explicitly

Minimum triage record:

| Finding | Source | Type | Disposition | Artifact / commit |
|---------|--------|------|-------------|-------------------|
| ...     | α/β/assessment | process/skill/... | immediate MCA / project MCI / agent MCI / drop | ... |

Silence is not triage. Every finding gets a disposition. Step 13a skill/spec patches are γ's to land or explicitly delegate.

2.8. Steps 10–11 — Enforce cycle-iteration outputs when triggers fire

Apply the cycle-iteration checks named in CDD.md step 10. For each fired trigger, γ must do something explicit:

Trigger	Fire condition	Required γ action	Closure rule
Review churn	review rounds > 2	Verify the assessment contains a Cycle Iteration entry naming the root cause and the chosen disposition (patch landed now / next MCA / no patch with reason).	If missing, cycle cannot close.
Mechanical overload	mechanical ratio > 20% and total findings ≥ 10	Verify the assessment names the recurring mechanical class and whether the mechanization patch was landed now or filed as a concrete MCA.	If missing, cycle cannot close.
Avoidable tooling / environment failure	environment or tooling blocked the cycle in a way a guardrail could likely prevent	Verify the assessment names the failure, workaround, and disposition (guard landed now / issue filed / no spec-level fix with reason).	If missing, cycle cannot close.
Loaded-skill miss	a loaded skill should have prevented a finding but did not	Patch the skill now when the correction is clear; otherwise verify the assessment names the exact skill gap and the concrete next MCA.	If neither patch nor committed MCA exists, cycle cannot close.

Each fired trigger must end in one of three states:

• patch landed now
• concrete next MCA committed
• explicit no-patch decision with reason

2.9. Step 13 — Run the independent γ process-gap check

Even if no cnos.cds/skills/cds/CDS.md §"Assessment" → §"Cycle iteration triggers" trigger fired, γ must still ask:

• Did this cycle reveal a recurring friction?
• Was any gate too weak or too vague?
• Did a role skill fail to prevent a predictable error?
• Did coordination burden show a better mechanical path?

If yes:

• patch the skill / spec now when clear, or
• commit the concrete next MCA (issue / owner / first AC)

If no:

• state why not in one sentence inside the assessment or γ close-out

• ❌ "No trigger fired, so nothing to do"

• ✅ "No formal trigger fired, but dispatch kept compensating for issue ambiguity; γ patches issue-quality gate now"

2.10. Steps 13–15 — Close only after the closure gate passes

Do not declare the cycle closed until all of the following are true:

1. .cdd/unreleased/{N}/alpha-closeout.md exists on main
2. .cdd/unreleased/{N}/beta-closeout.md exists on main
3. γ has written the post-release assessment per post-release/SKILL.md
4. every fired cycle-iteration trigger has a Cycle Iteration entry with root cause and disposition
5. recurring findings were assessed for skill / spec patching
6. immediate outputs were either landed or explicitly ruled out
7. deferred outputs have issue / owner / first AC
8. next MCA is named
9. hub memory is updated
10. merged remote branches are cleaned up
11. RELEASE.md is written and committed to main (§2.6)
12. cycle directories moved from .cdd/unreleased/{N}/ to .cdd/releases/{X.Y.Z}/{N}/ and committed to main (§2.6)
13. δ release-boundary preflight was requested and returned Proceed (mechanics: release-effector/SKILL.md; doctrinal frame: delta/SKILL.md §1)
14. if the cycle's receipt has protocol_gap_count > 0 (≥1 finding tagged cdd-skill-gap / cdd-protocol-gap / cdd-tooling-gap / cdd-metric-gap), .cdd/unreleased/{N}/cdd-iteration.md exists with each finding structured per post-release/SKILL.md Step 5.6b, and .cdd/iterations/INDEX.md has a row for cycle N. If any finding shipped to a different repo, .cdd/iterations/cross-repo/{target}/{slug}/ exists with bundle + LINEAGE.md. If protocol_gap_count == 0, no iteration file is required (per ROLES.md §4b.4, epsilon/SKILL.md §1, and activation/SKILL.md §22); the INDEX row is also not required for empty-findings cycles.

Then:

• write .cdd/unreleased/{N}/gamma-closeout.md. Contains: cycle summary, close-out triage table, §"Cycle iteration triggers" assessment, cycle iteration, skill gap candidate dispositions, deferred outputs, hub memory evidence, and next MCA. gamma-closeout.md is the closure declaration artifact. δ must not tag/release until it exists on main. See cnos.cds/skills/cds/CDS.md §"Artifact contract" → §"Ownership matrix".
• update hub memory
• delete merged remote branches (mechanics: release-effector/SKILL.md §5)
• state closure explicitly: "Cycle #N closed. Next: #M." This is γ's last commit. δ will cut the disconnect release (step 17) — the tag appearing on main is the observable proof the cycle is fully closed.

2.11. γ as autonomous coordinator

On each polling transition, γ matches the event against named decision-points and acts: act autonomously / pause / ignore. γ does not track the cycle as a managerial verb — γ polls (mechanics: harness/SKILL.md §5.4) and on each transition produces a decision (the autonomous-coordinator artifact).

Decision-point matching:

Decision point	γ action
Selection commit / Scope expansion / P0 override / β-approved merge of high-blast-radius / Design-call γ cannot resolve / Conflict-of-interest escalation / Process-debt commitment	pause (structured report to operator)
Normal unblocking / artifact coordination	act autonomously
γ's own commits / no-op transitions	ignore

Operator-facing report shapes. γ surfaces consolidated state, not per-transition noise:

• TLDR (3–5 bullets at consolidated state): issue status / cycle branch SHA + CI / last commits / open findings / blocked-on
• Decision-request: 1-sentence problem / options with trade-offs / γ recommendation / impact-if-delayed
• Deferred-question batch: collect at natural coordination pauses, surface as batch

Kata — 3-round autonomous cycle. γ drives a substantial cycle (≥5 ACs) with one mid-cycle clarification: (1) selects, creates issue, requests α/β dispatch; (2) α signals review-readiness, β returns RC; (3) γ writes clarification, requests α fix-round; (4) α fixes, β approves, merge completes; (5) γ writes PRA, triages, closes; (6) δ cuts release — no operator interaction except at spawn time. Success criterion: operator receives only the final TLDR.

---

3. Rules

3.1. Select by rule order, not taste

The candidate you like is irrelevant if a stronger CDD.md rule applies.

3.2. Name the decisive clause

Every selected gap must record the CDD.md clause that made it win.

3.3. Make the issue executable before dispatch

Prompt cleverness is not a substitute for issue quality.

3.4. Name only Tier 3 skills in the issue

Tier 1 and Tier 2 are already mandatory. Repeating them hides the real issue-specific constraints.

3.5. Preserve epistemic separation

γ sees both sides because coordination requires it. γ transfers artifact facts only.

3.6. Land immediate process fixes in the same cycle when possible

A missing gate discovered this cycle should not automatically become future work when the patch is already clear.

3.7. Do not close the cycle with unresolved triage

"Noted" is not a disposition.

3.8. Silence rule

γ does not surface every transition to the operator; γ surfaces only decision-points and consolidated state. A noisy γ is an unencapsulated γ.

• ❌ "α committed at SHA abc123; β is reviewing; CI is running"
• ❌ "Found 3 findings in β round 1; α is fixing finding #2"
• ❌ "Polling detected branch update; reading new self-coherence.md"
• ✅ "Selection decision needed: P0 vs committed next-MCA" (decision-point hit)
• ✅ "TLDR requested: Issue #286, cycle/286 at def456, β approved, ready for merge"
• ✅ "Cycle #286 closed. Next: #287." (consolidated state at closure)

3.9. Managerial-residue sweep (binding before any γ-skill patch)

Per COHERENCE-CELL.md §γ and δ Managerial-Residue Sweep: any γ verb that does not produce an artifact, receipt, or boundary decision is suspect. Monitor, track, supervise, oversee, manage are sweep-suspect; rename to the biological function (observe, discriminate, route, validate, close, transport, release, repair-dispatch) or relocate the mechanics to the substrate (harness/SKILL.md, release-effector/SKILL.md). Coordination is legitimate; runtime supervision mechanics belong below γ.

---

4. Embedded Kata

Kata A — Selection

Scenario. Three candidates: a newly noticed feature idea / a stale process issue from two cycles ago / a small infra script fix taking five minutes.

Task. Select the next move; justify using CDD.md rule order.

Expected. Immediate-output executed now if truly immediate; stale issue chosen for the next substantial MCA if the governing clause forces it; explicit decisive clause named.

Kata B — Issue quality

Scenario. An issue says only: "Fix package restore; it's incoherent."

Task. Rewrite into a dispatchable γ issue pack.

Required fields. Concise gap / evidence / numbered ACs / non-goals / Tier 3 skills / active design constraints / related artifacts / priority / work-shape note / dependency note when applicable.

Common failures. Repeats Tier 1/2 skills; vague ACs; omits non-goals; leaves α to infer the invariant.

Kata C — Cycle iteration

Scenario. A cycle finished with 3 review rounds, 12 findings (5 mechanical), one loaded-skill miss, no process patch yet committed.

Task. State what γ must require before closure.

Expected. Cycle Iteration section in the assessment; root cause named for review churn / mechanical overload / skill miss; disposition for each fired trigger; closure blocked until landed patch, concrete next MCA, or explicit no-patch justification exists.

Resumption

When dispatched to an artifact path that already contains a section manifest, γ follows cnos.cds/skills/cds/CDS.md §"Large-file authoring rule" → §"Resumption protocol": (1) read existing manifest, (2) verify completed sections are coherent and complete, (3) continue from the first uncompleted section, (4) update manifest on each completion. γ-specific resumption cases: gamma-closeout.md (sections [Close-out Triage, Trigger Assessment, Cycle Iteration, Deferred Outputs, Next-MCA Commitment]); PRA (large multi-section); dispatch coordination (mid-prompt-generation resume). Never restart completed sections — they encode settled γ coordination decisions.