cyber-sdd 0.0.0

package/skills/plan-retirement/SKILL.md

@@ -0,0 +1,90 @@
+---
+name: plan-retirement
+description: "Partial Skill: invoke by name only — the SDD Doctrine loop's last retro step — the gated, idempotent tracked deletion of a retired mission plan. Invoked by the doctrine-loop Scanner, not user-triggered; the clearance contract lives in the body + README."
+user-invocable: false
+metadata:
+  internal: true
+---
+
+# SDD Plan Retirement
+
+The Doctrine loop's **last retro step** (`sdd:doctrine-loop`; the provenance shape is
+`sdd:combat-log-governance`). Because plans are **tracked** (committed with
+the work, not gitignored), a retired plan leaves the tree by a deliberate **tracked deletion** —
+never a gitignore side effect. This skill carries a self-contained `.mts` sweep that, for each
+cleared `<cr-ref>`, deletes that CR's whole **transient artifact set**: the plan pair
+(`<cr-ref>.plan.md` + `<cr-ref>.log.jsonl`) plus its **transient CR-level planning briefs**
+(`<cr-ref>.design.md`, `<cr-ref>.operations.md`, `<cr-ref>.evidence.md`) from `.agents/plans` —
+so a retired CR leaves no orphan behind.
+
+## The transient briefs ride along, never gate
+
+`design.md` / `operations.md` / `evidence.md` are optional, cr-ref-scoped planning briefs that
+share the plan's lifetime. They retire alongside the plan pair but do not participate in the
+retirement decision. Two boundaries:
+
+- **They do not widen the distilled gate.** The gate keys on the combat log's presence only — a
+  cr-ref with briefs but no `log.jsonl` still retires without a distilling `strategy` entry. A
+  brief owes no distillation (its content was consumed by the mission itself).
+- **They do not anchor presence.** `<cr-ref>.plan.md` is the sole presence signal. A brief
+  without a `plan.md` is left untouched.
+
+## Distill and delete are decoupled
+
+- **Distill (early).** At `→ implemented`, the Scanner reads the concluded combat log and distills
+  recurring `cause`s into the ledger's `strategy` lines (`sdd:doctrine-loop`).
+- **Delete (late).** This sweep runs as a **separate, later** step, gated on source = `done`/merged
+  **and** the plan distilled. Never delete an un-distilled plan (the retro never ran).
+
+## The clearance boundary — split by verifiability
+
+The two gating signals split by what the sweep can check itself:
+
+- **source = `done`/merged** — the **caller's judgment**: query the source natively (`github-NN` → GH
+  issue, `asana-<gid>` → Asana, `local-<slug>` → the local store); needs network/`gh`. The caller
+  passes the source-cleared set via `--retire`.
+- **distilled** — **verified mechanically by the sweep**: a `strategy` entry with `distills ==
+  <cr-ref>` must exist in the project ledger (`--ledger`). The sweep keys on the structured
+  `distills` field, **never** a `<cr-ref>` that appears only in a strategy's `evidence`
+  cross-references, and an **unratified** distilling entry still counts
+  (`sdd:combat-log-governance`). Its absence is **fail-closed** — but only when a combat log
+  **exists**: a cr-ref whose `<cr-ref>.log.jsonl` was never written (a non-gated mission — hand-run,
+  chore-tracked, investigation — runs no gate cycle and emits no correction) has **nothing to
+  distill**, so it retires on clearance + presence alone. The fail-closed leaves an existing,
+  undistilled log's plan intact so its distillation can still be drafted.
+
+Leaving the distilled half to the caller once let a plan + combat log be deleted before any
+distillation existed (the evidence the distill was meant to preserve). Because the check is local,
+the sweep does it itself. Only the genuinely non-local judgment (source status) stays with the caller.
+
+## Run the sweep
+
+```bash
+node "<skill>/scripts/retire-plans.mts" \
+  --root .agents/plans \
+  --ledger .agents/specs/<project>/ledger \
+  --retire github-34,asana-7 [--dry-run]
+```
+
+- **`--ledger <dir>`** points at the project's ledger directory (the `ledger/` sibling of the root
+  `spec.md`). **Required for any deletion** — omit it (or an unreadable dir) and the sweep
+  fail-closes: nothing is deleted (the no-log branch only applies once a ledger is present to consult).
+- Deletes the transient artifact set (`<cr-ref>.plan.md`, `<cr-ref>.log.jsonl`,
+  `<cr-ref>.design.md`, `<cr-ref>.operations.md`, `<cr-ref>.evidence.md`) only for a `<cr-ref>` that
+  is cleared (`--retire`) **and** present on disk (`<cr-ref>.plan.md` exists) **and** either
+  distilled (a `strategy` with `distills == <cr-ref>` in `--ledger`) **or** has no combat log to
+  distill (no `<cr-ref>.log.jsonl` on disk). Each brief is deleted only if present; an absent one is
+  a no-op, same as the missing log half.
+- **Fail-closed** — a plan not named in `--retire`, or whose combat log **exists** but has no
+  distilling ledger entry, is never touched (and neither are its briefs).
+- **Idempotent** — a cleared `<cr-ref>` with no plan on disk (already retired, or an open CR the
+  caller declined to clear) is a no-op, even if a brief for it exists; the sweep is safe to re-run.
+- `--dry-run` prints the planned deletions without touching the tree.
+
+When `node` is absent, an agent performs the same decision by hand: for each cleared `<cr-ref>`, if
+its `<cr-ref>.log.jsonl` **exists**, **first confirm a `strategy` entry with `distills == <cr-ref>`
+exists in the project ledger** (not a mere `evidence` mention; unratified still counts) — if none,
+skip it. A cr-ref with **no** `log.jsonl` has nothing to distill and needs no such entry. Only then
+delete `<cr-ref>.plan.md`, `<cr-ref>.log.jsonl`, `<cr-ref>.design.md`, `<cr-ref>.operations.md`, and
+`<cr-ref>.evidence.md` if present, touching nothing else — and only if `<cr-ref>.plan.md` is
+present in the first place (a brief alone never triggers deletion).

package/skills/plan-retirement/scripts/retire-plans.mts

@@ -0,0 +1,196 @@
+#!/usr/bin/env node
+// Plan retirement — the Doctrine loop's last retro step (see sdd:combat-log-governance,
+// "Plan retirement"). A retired plan leaves the tree by a deliberate, gated TRACKED
+// DELETION, never a gitignore side effect: for each cleared <cr-ref>, the sweep deletes that
+// CR's whole TRANSIENT ARTIFACT SET — the plan pair (<cr-ref>.plan.md + <cr-ref>.log.jsonl)
+// plus its transient CR-level planning briefs (<cr-ref>.design.md, <cr-ref>.operations.md,
+// <cr-ref>.evidence.md) — from `.agents/plans`.
+//
+// The two gating signals split by verifiability. Source = done/merged stays the CALLER's
+// judgment: the source-status query (github-NN -> GH issue, asana-<gid> -> Asana,
+// local-<slug> -> the local store) needs network/gh, so the Scanner (doctrine-loop delegate)
+// determines it and passes the CLEARED set via --retire. Distilled is local and mechanically
+// checkable, so the sweep VERIFIES IT ITSELF against the project ledger (--ledger <dir>): a
+// `strategy` entry whose `distills` field equals the <cr-ref> must exist. The distilled gate
+// only guards a cr-ref whose combat log EXISTS — there is something on disk it could still
+// distill from, so retirement without a distilling entry would be data loss. A cr-ref whose
+// <cr-ref>.log.jsonl was never written has nothing to distill from in the first place, so it
+// retires on clearance + presence alone, no distilling entry required. This is the
+// mechanical, fail-closed gate + filesystem act:
+//   - it deletes the transient artifact set for a cr-ref that is cleared AND present on disk
+//     AND (distilled per the ledger OR has no log.jsonl to distill from);
+//   - a missing/unreadable --ledger skips retirement for ALL cr-refs (the no-log branch only
+//     applies once a ledger is actually present to consult);
+//   - anything not cleared, not present, or already gone is a no-op (idempotent, safe to
+//     re-run);
+//   - it never touches a plan it was not explicitly cleared to retire (fail-closed).
+//
+// Two invariants on the transient briefs (design.md / operations.md / evidence.md), both
+// deliberate:
+//   - THEY DO NOT WIDEN THE DISTILLED GATE. The gate keys on the combat log's presence only
+//     (discoverLogs / logPresent) — a cr-ref with briefs but no log.jsonl still retires
+//     without a distilling strategy. A brief owes no distillation (its content was consumed
+//     by the mission itself, not extracted into the ledger), so gating on one would re-strand
+//     the no-log mission class the no-log branch exists to rescue.
+//   - THEY DO NOT ANCHOR PRESENCE. discoverPlans (keyed on .plan.md) stays the sole presence
+//     signal. A cr-ref with a design.md but no plan.md is a no-op — the idempotency contract
+//     (a cleared cr-ref with no plan on disk deletes nothing) is the stronger guarantee.
+//
+// Pure functions are exported for node:test; running the file directly drives the CLI.
+// No dependencies. Use --dry-run to print the planned deletions without touching the tree.
+
+import { existsSync, readdirSync, readFileSync, unlinkSync } from 'node:fs'
+import { join } from 'node:path'
+
+const PLAN_SUFFIX = '.plan.md'
+const LOG_SUFFIX = '.log.jsonl'
+const DESIGN_SUFFIX = '.design.md'
+const OPERATIONS_SUFFIX = '.operations.md'
+const EVIDENCE_SUFFIX = '.evidence.md'
+
+// The full transient artifact set a retired cr-ref owns, in deletion order: the plan pair
+// (plan.md, log.jsonl) then the optional transient CR-level planning briefs (design.md,
+// operations.md, evidence.md). The briefs are optional — the per-file existsSync guard in
+// main() no-ops any that are absent, which is what lets a cr-ref with only some briefs retire
+// cleanly.
+export function transientArtifactFiles(crRef: string): string[] {
+	return [
+		`${crRef}${PLAN_SUFFIX}`,
+		`${crRef}${LOG_SUFFIX}`,
+		`${crRef}${DESIGN_SUFFIX}`,
+		`${crRef}${OPERATIONS_SUFFIX}`,
+		`${crRef}${EVIDENCE_SUFFIX}`,
+	]
+}
+
+// Parse a --retire value (comma-separated cr-refs) into a clean, de-duplicated list.
+export function parseCleared(value: string | undefined): string[] {
+	if (!value) return []
+	const seen = new Set<string>()
+	for (const raw of value.split(',')) {
+		const ref = raw.trim()
+		if (ref) seen.add(ref)
+	}
+	return [...seen]
+}
+
+// The cr-refs that have a <cr-ref>.plan.md on disk under `root`.
+export function discoverPlans(root: string): string[] {
+	let entries: string[]
+	try {
+		entries = readdirSync(root)
+	} catch {
+		return []
+	}
+	return entries.filter((f) => f.endsWith(PLAN_SUFFIX)).map((f) => f.slice(0, -PLAN_SUFFIX.length))
+}
+
+// The cr-refs that have a <cr-ref>.log.jsonl on disk under `root`.
+export function discoverLogs(root: string): string[] {
+	let entries: string[]
+	try {
+		entries = readdirSync(root)
+	} catch {
+		return []
+	}
+	return entries.filter((f) => f.endsWith(LOG_SUFFIX)).map((f) => f.slice(0, -LOG_SUFFIX.length))
+}
+
+// The cr-refs the project ledger records as DISTILLED — a `strategy` entry whose `distills`
+// field equals the cr-ref exists in some *.jsonl shard under `ledgerDir`. Keys on the
+// structured `distills` field only: a cr-ref named merely inside a strategy's `evidence`
+// array (a cross-reference) does NOT count, and an unratified entry (`ratified: false`, the
+// Scanner's default) still counts — the gate is about what was distilled, not sign-off.
+// Malformed lines and a missing/unreadable ledger dir are tolerated: fail-closed means an
+// unverifiable ledger yields an EMPTY set, never a thrown error.
+export function distilledCrRefs(ledgerDir: string): Set<string> {
+	const distilled = new Set<string>()
+	let entries: string[]
+	try {
+		entries = readdirSync(ledgerDir)
+	} catch {
+		return distilled
+	}
+	for (const entry of entries) {
+		if (!entry.endsWith('.jsonl')) continue
+		let text: string
+		try {
+			text = readFileSync(join(ledgerDir, entry), 'utf8')
+		} catch {
+			continue
+		}
+		for (const line of text.split('\n')) {
+			const trimmed = line.trim()
+			if (!trimmed) continue
+			let record: unknown
+			try {
+				record = JSON.parse(trimmed)
+			} catch {
+				continue
+			}
+			if (record === null || typeof record !== 'object') continue
+			const { kind, distills } = record as { kind?: unknown; distills?: unknown }
+			if (kind === 'strategy' && typeof distills === 'string' && distills.length > 0) distilled.add(distills)
+		}
+	}
+	return distilled
+}
+
+// Fail-closed, idempotent decision: retire exactly the cr-refs that are cleared by the caller,
+// present on disk, AND either distilled per the ledger OR have no combat log to distill from
+// (log.jsonl absent). An uncleared or absent plan is never retired; a present plan whose log
+// DOES exist still requires a distilling entry (data-loss guard, unchanged). Order follows the
+// cleared list for stable reporting.
+export function decideRetirements(
+	cleared: string[],
+	existing: string[],
+	distilled: Set<string>,
+	logPresent: Set<string>,
+): string[] {
+	const present = new Set(existing)
+	const seen = new Set<string>()
+	const out: string[] = []
+	for (const ref of cleared) {
+		if (present.has(ref) && (distilled.has(ref) || !logPresent.has(ref)) && !seen.has(ref)) {
+			seen.add(ref)
+			out.push(ref)
+		}
+	}
+	return out
+}
+
+export function main(argv: string[]): number {
+	const root = argv.includes('--root') ? argv[argv.indexOf('--root') + 1] : '.agents/plans'
+	const ledgerArg = argv.includes('--ledger') ? argv[argv.indexOf('--ledger') + 1] : undefined
+	const cleared = parseCleared(argv.includes('--retire') ? argv[argv.indexOf('--retire') + 1] : undefined)
+	const dryRun = argv.includes('--dry-run')
+
+	let retiring: string[]
+	if (!ledgerArg || !existsSync(ledgerArg)) {
+		process.stdout.write(
+			`no verifiable ledger (${ledgerArg ? `--ledger ${ledgerArg} unreadable` : '--ledger not given'}): distillation cannot be checked, so retirement is skipped for all cr-refs\n`,
+		)
+		retiring = []
+	} else {
+		const distilled = distilledCrRefs(ledgerArg)
+		const logPresent = new Set(discoverLogs(root))
+		retiring = decideRetirements(cleared, discoverPlans(root), distilled, logPresent)
+	}
+	const deleted: string[] = []
+
+	for (const ref of retiring) {
+		for (const file of transientArtifactFiles(ref)) {
+			const path = join(root, file)
+			if (!existsSync(path)) continue // the log may be absent; delete what is there
+			if (!dryRun) unlinkSync(path)
+			deleted.push(path)
+		}
+	}
+
+	const verb = dryRun ? 'would delete' : 'deleted'
+	for (const path of deleted) process.stdout.write(`${verb} ${path}\n`)
+	process.stdout.write(`${dryRun ? 'dry-run: ' : ''}retired ${retiring.length} plan(s), ${deleted.length} file(s)\n`)
+	return 0
+}
+
+if (import.meta.main) process.exit(main(process.argv.slice(2)))

package/skills/plugin-contract-governance/README.md

@@ -0,0 +1,12 @@
+# plugin-contract-governance
+
+Internal SDD governance (`user-invocable: false`). The **plugin contract** — what an SDD plugin must
+implement: the five delegate roles (closed set), the per-role governance loadout (the Model-B
+`(actor, gate)` bars + the fixed-universal set), and the `sdd-plugins[]` registry entry shape +
+resolution by `artifact-type`.
+
+A **single-owner** governance — its consumer family is the plugin/conductor resolution surface, so it
+lives under `plugin/`, not `common-governances/`. Loaded by the conductor and by plugin authors. The
+universal-plugin *format* is `plugin-design` (out of scope); resolution/composition mechanics are the
+`resolve-governances` skill; the actor bars are the shipped
+`sdd:{oracle,builder,architect}-{spec,impl}-governance` skills. Not triggered by users directly.

package/skills/plugin-contract-governance/SKILL.md

@@ -0,0 +1,112 @@
+---
+name: plugin-contract-governance
+description: "Partial Skill: invoke by name only — the SDD plugin contract for what a plugin implements. Loaded by the conductor and by plugin authors, not user-triggered."
+user-invocable: false
+---
+
+# SDD Plugin Contract Governance
+
+What an SDD plugin must implement and what each part loads. The conductor resolves delegates against
+this contract; a plugin author builds to it. The universal-plugin format itself is `plugin-design`
+(`governance show universal-plugin`); this skill is the SDD-role layer on top.
+
+## The five delegate roles (closed set)
+
+A plugin covers a set of artifact-types by providing agents for these role keys. Any role may be
+`null` (degenerates to the SDD default) or omitted (falls back to the convention name
+`<plugin>-<role>`). A **producer** role may also name a model-tuned agent to run at its own
+model/effort — the model-tuning escape valve; naming any agent (plugin delegate or model-tuned)
+means the conductor **spawns** it.
+
+| Role key | Acts | SDD default |
+|---|---|---|
+| `spec-producer` | writes the `spec.md` body + the `.feature` | conductor loads `spec-producer-governance`, authors inline (`sdd:automaton`) |
+| `solution-producer` | writes `<unit>.solution.md` (the durable, ungated design fork) | conductor loads `solution-producer-governance`, authors inline (`sdd:automaton`) |
+| `spec-judge` | judges `spec.md` + the `.feature` at the spec gate | `sdd-spec-judge` — spawned cold agent |
+| `impl-producer` | builds the artifact **and** its verification | conductor loads `impl-producer-governance`, dispatches a generic builder (`sdd:automaton`) |
+| `impl-judge` | runs the verification against the frozen `.feature` | `sdd-impl-judge` — spawned cold agent |
+
+**Producers run inline (or via a mechanical builder), judges spawn cold** ("conductor writes, cold
+judges grade"): an SDD-default spec/solution-producer is a governance the conductor loads and runs in
+its own warm main-session context (recorded `produced-by.<role>: sdd:automaton`); the SDD-default
+impl-producer is mechanical and spawned via a generic builder; an SDD-default judge is a cold agent
+the conductor spawns, because a grader must not share the author's context. A plugin delegate — or a
+model-tuned producer agent named for the slot — is always spawned.
+
+Any of the spawns above may instead be realized through a general-purpose dispatch capability's
+`subagent | channel` seam (ADR-0023, referenced by intent only) — an alternative realization of the
+same spawn, not a change to which roles spawn or how they are graded.
+
+> The legacy role key was `plan-producer` (writing `plan.md` + `tasks.md`); it is renamed
+> **`solution-producer`** writing `<unit>.solution.md` (`sdd:combat-log-governance`). A live registry
+> still carrying `plan-producer` is migrated on encounter.
+
+## Which governances each role loads
+
+Bars are the Model-B `(actor, gate)` governances (matched by the `resolve-governances` skill; the
+actor bars are the shipped `sdd:{oracle,builder,architect}-{spec,impl}-governance` skills); a producer
+self-aligns to exactly the bars its judge grades. The lens sets are spec gate `{oracle, builder,
+architect}`, impl gate `{builder, architect}`, solution `{architect}` (ungated).
+
+| Role | Loads |
+|---|---|
+| spec-producer | `spec-format`, `suite-format`, `ownership`, the resolved `oracle-spec` + `builder-spec` bars |
+| solution-producer | `ownership`, the resolved `architect-spec` bar |
+| spec-judge | `spec-format`, `suite-format`, `lifecycle`, `gate-validation`, the resolved `oracle-spec` + `builder-spec` + `architect-spec` bars |
+| impl-producer | `ownership`, the resolved `builder-impl` + `architect-impl` bars |
+| impl-judge | `ownership`, `gate-validation`, the resolved `builder-impl` + `architect-impl` bars |
+
+For an **SDD-default producer** role, the conductor additionally loads the matching
+`spec-producer-governance` / `solution-producer-governance` / `impl-producer-governance` — the
+procedure it runs — which itself references the bars above; a plugin delegate carries its own
+procedure and loads these bars directly.
+
+The `sdd` gateway loads **no** governance (it only classifies and routes). The gate skill
+`spec-gate` loads `lifecycle`, `ownership`, `gate-validation`, `combat-log` (+ `spec-format` /
+`suite-format` at the spec gate). A plugin's agents inherit the universal loads — e.g. `aced`/`quill`
+spec-producers load `sdd:spec-format-governance` + `sdd:ownership-governance`, and their judges load
+`sdd:gate-validation-governance`.
+
+## Registry shape
+
+The conductor reads **only** `.agents/universal-plugin.json` (top-level `sdd-plugins[]`) — it does
+not scan plugin directories. Each entry:
+
+```json
+{
+  "name": "<plugin>",
+  "version": "<semver>",
+  "squads": [
+    {
+      "artifact-types": ["<artifact-type>", "..."],
+      "roles": {
+        "spec-producer":     "<agent | null>",
+        "solution-producer": "<agent | null>",
+        "spec-judge":        "<agent | null>",
+        "impl-producer":     "<agent | null>",
+        "impl-judge":        "<agent | null>"
+      },
+      "governances": {
+        "oracle-spec":  "<name | null>",
+        "builder-spec":   "<name | null>",
+        "builder-impl":   "<name | null>",
+        "architect-spec": "<name | null>",
+        "architect-impl": "<name | null>"
+      }
+    }
+  ]
+}
+```
+
+A plugin declares one or more **squads**, each serving a **set of artifact-types** with one
+production chain; a type appears in at most one squad per plugin (the plugin's served set = the union
+of its squads' `artifact-types`).
+
+Resolution: match each file's **`artifact-type`** (the squad key, **not** the folder name) against
+each plugin's `squads[]` — the squad whose `artifact-types` contains it serves the file (e.g. ACED's
+one squad covers `skill`, `subagent`, `command`, `agents-section`). An absent or unmatched
+`artifact-type` → all roles degenerate to SDD defaults. One matching squad → resolve each role and
+governance key (name = use it; `null` = SDD default; missing role key = `<plugin>-<role>`). Two or
+more plugins claiming the type → return `STATUS: needs-input` for the skill to ask which plugin owns
+it; the choice is recorded as `.agents/sdd/` resolution state (**distinct from `produced-by`**),
+decisive on resume.

package/skills/remediation-governance/README.md

@@ -0,0 +1,46 @@
+# remediation-governance
+
+This is an internal SDD governance about **what a producer does when a gate sends work back**.
+
+A gate returns one of three verdicts. `approve` and `reject` end the round. **`change`** sends the
+work back with findings — and this bar governs what happens next.
+
+Its single claim: **the findings are evidence, not a work order.** The tempting response is to read
+them as a task list and edit each cited line. That fixes the lines and leaves the defect, because a
+judge can only ever name the instances it happened to see.
+
+## What it requires — the four rules
+
+| Rule | What it means |
+| --- | --- |
+| **Substantiate first** | A finding is a claim about the artifact, and claims can be wrong. Check it before changing anything. One that does not hold is **contested** — send back the evidence and change nothing. |
+| **State the rule, then sweep** | The finding names one instance; the actual defect is the rule it breaks. Name that rule, then search for every other place it is broken — in a script, so anyone can re-run it. Report what you looked at and **ruled out**, not only what you found. |
+| **Re-derive against the governing rule** | Check the fix against the rule that governs the artifact, not just against the finding. "Does it still trip the finding?" is weak. "Is what it now says **true**?" is the question — a fix that satisfies the finding while breaking a rule the artifact is bound by is worse than the original defect. |
+| **Account for provenance** | For each finding, ask whether the artifact it names was changed by the **last** round of fixes. If so it is a **regression** — the fixes are creating work rather than finishing it, and the loop stops for a re-plan instead of running again. |
+
+## Sweeping is not string-matching
+
+The most common way rule 2 goes wrong is a blanket search. A term retired in one place may be
+correct in another, and the same word may name a different thing in a sibling project. Three
+separations matter: **use vs mention** (deploying a retired term versus naming it *to say* it is
+deprecated), **scope** (the live spec is bound; ADRs and ledger lines are history and are never
+rewritten), and **word boundaries** (a substring is not an instance).
+
+## Usage
+
+- **spec-producer:** responding to a `change` verdict at the **spec gate**
+- **impl-producer:** responding to a `change` verdict at the **impl gate**
+
+Both return the trace — rule, sweep hits, ruled-out candidates, provenance — in their `Output`, which
+is what lets the next judge check the remediation instead of taking it on trust.
+
+## Related governances
+
+- **`spec-producer-governance`** / **`impl-producer-governance`** — the producers that load this bar;
+  they own *how the work is done*, this bar owns *how a returned verdict is answered*.
+- **`gate-validation-governance`** — which gate states are legal; this bar is silent on state and
+  governs only the response.
+- **`suite-format-governance`** / **`spec-format-governance`** — the rules a correction is re-derived
+  against under rule 3.
+
+Internal SDD governance (`user-invocable: false`). Not triggered by users directly.

package/skills/remediation-governance/SKILL.md

@@ -0,0 +1,78 @@
+---
+name: remediation-governance
+description: "Partial Skill: invoke by name only — the SDD remediation bar: how a producer responds to a `change` verdict at either gate. Loaded by the spec-producer and the impl-producer, not user-triggered."
+user-invocable: false
+---
+
+# Remediation Governance — responding to a `change` verdict
+
+A gate verdict's findings are **evidence to reason from**, never a task list to execute. Working down
+the list edit-by-edit fixes cited lines while leaving the defect, and can introduce defects the next
+round then reports.
+
+This bar applies at **both** gates — the spec gate and the impl gate — and is loaded by whichever
+producer is responding.
+
+## The four rules
+
+1. **Substantiate each finding first.** A finding is a **hypothesis**. Verify it against the artifact
+   before touching anything. One you cannot substantiate is **contested** — return your evidence and
+   edit nothing. Fixing an unverified finding is how a vague line becomes a wrong one.
+2. **State the rule, then sweep.** A judge names an **instance**; the defect is the **rule**. Name
+   the rule the finding instantiates and sweep for every other instance — in a script, so the result
+   is reproducible. Return the sweep's **negative** half too: the candidates inspected and excluded,
+   so the next reader need not re-run it.
+3. **Re-derive the correction against the rule governing the artifact**, not merely against the
+   finding. "Does this still trip the finding?" is the weak question. "Is what it now says **true**?"
+   is the one that matters — a correction that clears the finding while contradicting a governance
+   the artifact is bound by is a worse defect than the one it replaced.
+4. **Account for each finding's provenance.** A finding is a **regression** when the artifact it
+   names was changed by the **previous remediation round's commits**; it is **pre-existing** when the
+   artifact predates them. Any regression means the loop is **no longer converging**: stop, report
+   it, and re-plan. Do not open another remediation round on a regressing loop.
+
+## A sweep is scope-aware, never a blanket match
+
+Rule 2's sweep answers "every instance of the rule", which is **not** "every occurrence of a string".
+Before acting on a sweep, separate:
+
+- **use vs mention** — a retired term deployed as if current is the defect; the same term named *in
+  order to* mark it deprecated, or preserved in an append-only record, is correct.
+- **scope** — the live project spec is bound by the rule; ADRs and ledger lines are history and are
+  never rewritten to match current vocabulary; a sibling tree may use the same word for a different
+  concept.
+- **word boundaries** — a substring hit is not an instance.
+
+Report the excluded candidates with the reason each was excluded. A sweep that reports only its hits
+cannot be checked, and invites the next producer to re-run it.
+
+## What the producer returns
+
+Remediation is **verifiable only if it leaves a trace**. Each finding answered carries, in the
+producer's `Output`:
+
+```
+REMEDIATION:
+  <finding>: verdict=<remediated | contested>
+             rule=<the rule the finding instantiates>
+             swept=<the other instances found, or none>
+             ruled-out=<candidates inspected and excluded, with the reason>
+             provenance=<pre-existing | regression>
+```
+
+A `contested` finding carries the evidence against it and **no edit** to the artifact it named.
+
+## Key points (read-check)
+
+1. **A verdict is evidence, not a work order** — remediating cited lines one at a time is the defect
+   this bar exists to prevent.
+2. **Substantiate before acting** — an unsubstantiated finding is contested with evidence, not edited
+   away.
+3. **A finding names an instance; the defect is the rule** — sweep for every instance, and report the
+   ruled-out candidates as well as the hits.
+4. **A sweep is scope-aware** — use vs mention, scope, and word boundaries; a string match is not an
+   instance.
+5. **Re-derive the correction against the rule governing the artifact**, not against the finding
+   alone.
+6. **Provenance is derived from the diff** — an artifact changed by the previous round's commits
+   makes its finding a **regression**, which stops the loop for a re-plan rather than another round.

package/skills/resolve-governances/README.md

@@ -0,0 +1,18 @@
+# resolve-governances
+
+The concrete engine for **SDD governance resolution**.
+A non-user-invocable skill carrying a self-contained `.mts` script that, for a touched file's
+artifact-type, resolves each production-chain role to its agent plus the resolved-actor bars it loads
+— matching candidates across the project's `.agents/governances/` anchors, the matched plugin squad,
+and the sdd defaults.
+
+- **Skill contract:** [`SKILL.md`](./SKILL.md)
+- **Script:** [`scripts/resolve-governances.mts`](./scripts/resolve-governances.mts)
+- **Tests:** [`scripts/resolve-governances.test.mts`](./scripts/resolve-governances.test.mts) (`node:test`)
+
+```bash
+node scripts/resolve-governances.mts --root . --artifact-type skill
+```
+
+Consumed by the conductor (`start-mission`) and the cold judges (`sdd-spec-judge`, `sdd-impl-judge`)
+to load the right bars without hand-enumerating.

package/skills/resolve-governances/SKILL.md

@@ -0,0 +1,50 @@
+---
+name: resolve-governances
+description: "Partial Skill: invoke by name only — the SDD governance matcher, resolving which actor-bar governances apply to a touched file — run by the conductor and the cold spec/impl judges, not triggered by users directly."
+user-invocable: false
+metadata:
+  internal: true
+---
+
+# Resolve Governances
+
+The concrete engine for **SDD governance resolution**. For a
+touched file's **artifact-type** it names, per production-chain role, **which agent runs it** and
+**which resolved-actor bar candidates it loads** — matching governances across the caller-passed
+project anchors, the matched plugin squad (from the project registry
+`.agents/universal-plugin.json`), and the sdd defaults. It is a **dumb matcher**: it returns each
+bar's candidates **bucketed by tier** and does **not** order by precedence or apply `compose` — the
+consuming agent composes. The conductor and the cold judges run it so they **never hand-enumerate**
+the bars. It carries a self-contained `.mts` script (the repo's node-≥23.6 / no-deps convention).
+
+## Run the resolution
+
+```bash
+node "<skill>/scripts/resolve-governances.mts" --root . --artifact-type <type> --project <path> [--project-root <path>]
+```
+
+- `--root` is the **registry** location (default `.`) — `.agents/universal-plugin.json`.
+- `--project <path>` is the file's own project anchor (defaults to `--root`); `--project-root <path>`
+  is the outer shared layer in a **monorepo** (omit for a single-project repo). Anchors are
+  **caller-passed**, never discovered — the conductor knows the project from `discover-specs`'
+  `project-path` or context.
+- `--artifact-type <type>` emits the per-role plan as JSON: each role carries its resolved `agent`
+  and the **resolved-actor `bars`** only. Each bar's `candidates` are **bucketed by tier** —
+  `project` / `project-root` (direct-read file paths) and `plugin` / `sdd` (`<plugin>:<bar>` /
+  `sdd:<name>` harness-load refs). The **fixed-universal** governances are invariant per role and
+  stay declared in the role/agent definition — the matcher does not emit them.
+- `--path <file>` (no `--artifact-type`) consults the optional tiebreaker map
+  `.agents/sdd/artifact-types.toml`; a no-match prints a classify-by-convention note.
+- No `--artifact-type` and no `--path` → validates the registry is well-formed + unambiguous
+  (`governance registry OK`, or per-line violations).
+
+When `node` is absent, an agent performs the same matching by hand: read the registry, match each
+touched file's artifact-type to a squad, and name each role's agent + bar candidates per tier.
+
+## Boundaries
+
+It owns no lifecycle state and writes nothing — it **names** candidates; the consuming agent loads
+each (direct-read for project files, harness-load for plugin/sdd skills), reads each governance's own
+`compose`, and composes by precedence `sdd-default < plugin < project-root < project` (most-specific
+wins; `replace` supersedes). Registry matching is deterministic; **disambiguating** an artifact-type
+claimed by two plugins is the consumer's agentic step (the plan returns `status: needs-input`).