wicked-crew 0.7.1 → 0.7.3

package/dist/api/governance-wiki.d.ts

@@ -0,0 +1,28 @@
+/**
+ * The `/api/v1/governance/wiki/*` surface (wiki-mgmt) — the management wire for the graph-backed
+ * architecture wiki, so the wiki is VISIBLE (not just queryable): a scoreboard that tells a
+ * populated wiki from an ingested-once-and-decaying one, and a meta probe cheap enough for the
+ * UI to call on mount so an empty store shows an honest "nothing seeded — here's the runbook"
+ * instead of a blank table.
+ *
+ * Thin by design, like `campaigns/routes.ts`: the scoreboard is computed by wicked-core's
+ * governance layer (`wicked-governance::scoreboard`, read-only `open_store_ro` — safe beside the
+ * live single-writer daemon); the daemon keeps no shadow wiki state. Error posture mirrors the
+ * campaign surface: a build whose engine addon lacks the `governanceScoreboard` binding answers
+ * 501 (`GovernanceScoreboardUnsupportedError` — "upgrade the engine"), never 400 ("fix your
+ * request").
+ *
+ * Rule/ruleset BROWSE and RETIRE deliberately live elsewhere — this module adds no second door:
+ * `GET /governance/rules` (facet-filterable, retired rows flagged) is the browse surface and
+ * `DELETE /governance/rules/:id` (retire-not-delete, FINDING-038) is the kill switch, both in
+ * `api/routes.ts`.
+ */
+import type { FastifyInstance } from 'fastify';
+import { type CoreAdapter } from '../core/adapter.js';
+/**
+ * The authoring guide the honest empty state points at: the AW-13 seed runbook — frontmatter
+ * conventions, the `seed_wiki.py` driver, and the `wicked-core rules` ingest/fanout/relink CLIs.
+ */
+export declare const WIKI_AUTHORING_DOC = "https://github.com/mikeparcewski/wicked-core/blob/main/crates/wicked-governance/seed/README.md";
+export declare function registerGovernanceWikiRoutes(app: FastifyInstance, adapter: CoreAdapter): void;
+//# sourceMappingURL=governance-wiki.d.ts.map

package/dist/api/governance-wiki.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"governance-wiki.d.ts","sourceRoot":"","sources":["../../src/api/governance-wiki.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C,OAAO,EAAwC,KAAK,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAM5F;;;GAGG;AACH,eAAO,MAAM,kBAAkB,mGACmE,CAAC;AAMnG,wBAAgB,4BAA4B,CAAC,GAAG,EAAE,eAAe,EAAE,OAAO,EAAE,WAAW,GAAG,IAAI,CAwE7F"}

package/dist/api/governance-wiki.js

@@ -0,0 +1,97 @@
+/**
+ * The `/api/v1/governance/wiki/*` surface (wiki-mgmt) — the management wire for the graph-backed
+ * architecture wiki, so the wiki is VISIBLE (not just queryable): a scoreboard that tells a
+ * populated wiki from an ingested-once-and-decaying one, and a meta probe cheap enough for the
+ * UI to call on mount so an empty store shows an honest "nothing seeded — here's the runbook"
+ * instead of a blank table.
+ *
+ * Thin by design, like `campaigns/routes.ts`: the scoreboard is computed by wicked-core's
+ * governance layer (`wicked-governance::scoreboard`, read-only `open_store_ro` — safe beside the
+ * live single-writer daemon); the daemon keeps no shadow wiki state. Error posture mirrors the
+ * campaign surface: a build whose engine addon lacks the `governanceScoreboard` binding answers
+ * 501 (`GovernanceScoreboardUnsupportedError` — "upgrade the engine"), never 400 ("fix your
+ * request").
+ *
+ * Rule/ruleset BROWSE and RETIRE deliberately live elsewhere — this module adds no second door:
+ * `GET /governance/rules` (facet-filterable, retired rows flagged) is the browse surface and
+ * `DELETE /governance/rules/:id` (retire-not-delete, FINDING-038) is the kill switch, both in
+ * `api/routes.ts`.
+ */
+import { GovernanceScoreboardUnsupportedError } from '../core/adapter.js';
+import { API_PREFIX } from './api-prefix.js';
+const V = API_PREFIX;
+/**
+ * The authoring guide the honest empty state points at: the AW-13 seed runbook — frontmatter
+ * conventions, the `seed_wiki.py` driver, and the `wicked-core rules` ingest/fanout/relink CLIs.
+ */
+export const WIKI_AUTHORING_DOC = 'https://github.com/mikeparcewski/wicked-core/blob/main/crates/wicked-governance/seed/README.md';
+function message(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+export function registerGovernanceWikiRoutes(app, adapter) {
+    // The AW-23 population/connection scoreboard. `?docsRoot=` is the OPTIONAL docs root the
+    // typing half needs (the same directory `rules ingest --dir` consumed — enforcement_class
+    // lives in doc frontmatter, never on the rule node); omitted, the scoreboard still answers
+    // 200 with `typing.available: false` and the reason in-band — a wiki with no local docs
+    // checkout is a normal deployment, not an error.
+    app.get(`${V}/governance/wiki/scoreboard`, {
+        config: {
+            manifest: {
+                responseType: '{ scoreboard: GovernanceScoreboard }',
+                // 501: the installed engine addon predates the governanceScoreboard binding
+                // (wicked-core-ts < 0.7.4) — upgrade the engine, the request was already correct.
+                statusCodes: [200, 500, 501],
+            },
+        },
+    }, async (req, reply) => {
+        // Fastify parses a repeated `?docsRoot=a&docsRoot=b` into an array — take the first, and
+        // TRIM so a whitespace-only value means "no docs root" rather than a doomed doc scan.
+        const raw = req.query.docsRoot;
+        const first = Array.isArray(raw) ? raw[0] : raw;
+        const docsRoot = first?.trim() || undefined;
+        try {
+            const scoreboard = await adapter.governanceScoreboard(docsRoot);
+            return { scoreboard };
+        }
+        catch (err) {
+            if (err instanceof GovernanceScoreboardUnsupportedError) {
+                return reply.code(501).send({ error: err.message });
+            }
+            // An engine/store failure is OURS, not the caller's — there is nothing to fix in a
+            // bare GET, so nothing here maps to 400.
+            return reply.code(500).send({ error: message(err) });
+        }
+    });
+    // The wiki's honest empty-state signal. Works on EVERY addon (listConformanceRules is a
+    // required binding since crew#40), so the UI can always distinguish "nothing seeded — run the
+    // seed runbook" from "the engine can't tell me": `ruleset_count` is `null` (never a fabricated
+    // 0) on a build without the listRuleSets binding, and `scoreboard_available` says up front
+    // whether the scoreboard route will answer 200 here.
+    app.get(`${V}/governance/wiki/meta`, {
+        config: {
+            manifest: {
+                responseType: '{ meta: GovernanceWikiMeta }',
+                statusCodes: [200],
+            },
+        },
+    }, 
+    // Wrapped per crew house style — campaigns/rules/scoreboard all wrap, and studio's
+    // Wiki page reads `body.meta` (a bare seeded:false would read as "cannot tell").
+    async () => {
+        // NOTE: pre-0.7.4 addons funnel listConformanceRules through recall, which skips retired
+        // rows — so `rule_count` counts the LISTABLE rules. That is the right number for "is
+        // anything here": a store holding only retired rules has nothing recallable to show.
+        const rules = await adapter.listConformanceRules();
+        const rulesetCount = await adapter.countRuleSets();
+        return {
+            meta: {
+                seeded: rules.length > 0 || (rulesetCount ?? 0) > 0,
+                ruleset_count: rulesetCount,
+                rule_count: rules.length,
+                scoreboard_available: adapter.wikiScoreboardSupported(),
+                doc: WIKI_AUTHORING_DOC,
+            },
+        };
+    });
+}
+//# sourceMappingURL=governance-wiki.js.map

package/dist/api/governance-wiki.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"governance-wiki.js","sourceRoot":"","sources":["../../src/api/governance-wiki.ts"],"names":[],"mappings":"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"}

package/dist/api/routes.d.ts

@@ -10,6 +10,7 @@ import { InteractiveBridgePool } from '../interactive/bridge-pool.js';
 import { AuditLog } from './audit.js';
 import { RetryIndex } from './retry-index.js';
 import { GuidanceIndex } from './guidance-index.js';
+import { DeliveryIndex } from './delivery-index.js';
 import { type AuthMode } from './auth.js';
 export { API_PREFIX } from './api-prefix.js';
 /**
@@ -48,46 +49,46 @@ export declare const LaunchSchema: z.ZodEffects<z.ZodObject<{
     problem: string;
     deliver?: "pr" | undefined;
     projectId?: string | undefined;
-    retryOf?: string | undefined;
-    sessionId?: string | undefined;
+    workflow?: string | undefined;
+    repoRef?: string | undefined;
     clisJson?: string | undefined;
+    sessionId?: string | undefined;
+    retryOf?: string | undefined;
     entityMode?: "shared" | "isolated" | undefined;
     humanConfirm?: string | undefined;
-    repoRef?: string | undefined;
-    workflow?: string | undefined;
 }, {
     problem: string;
     deliver?: "pr" | undefined;
     projectId?: string | undefined;
-    retryOf?: string | undefined;
-    sessionId?: string | undefined;
+    workflow?: string | undefined;
+    repoRef?: string | undefined;
     clisJson?: string | undefined;
+    sessionId?: string | undefined;
+    retryOf?: string | undefined;
     entityMode?: "shared" | "isolated" | undefined;
     humanConfirm?: string | undefined;
-    repoRef?: string | undefined;
-    workflow?: string | undefined;
 }>, {
     problem: string;
     deliver?: "pr" | undefined;
     projectId?: string | undefined;
-    retryOf?: string | undefined;
-    sessionId?: string | undefined;
+    workflow?: string | undefined;
+    repoRef?: string | undefined;
     clisJson?: string | undefined;
+    sessionId?: string | undefined;
+    retryOf?: string | undefined;
     entityMode?: "shared" | "isolated" | undefined;
     humanConfirm?: string | undefined;
-    repoRef?: string | undefined;
-    workflow?: string | undefined;
 }, {
     problem: string;
     deliver?: "pr" | undefined;
     projectId?: string | undefined;
-    retryOf?: string | undefined;
-    sessionId?: string | undefined;
+    workflow?: string | undefined;
+    repoRef?: string | undefined;
     clisJson?: string | undefined;
+    sessionId?: string | undefined;
+    retryOf?: string | undefined;
     entityMode?: "shared" | "isolated" | undefined;
     humanConfirm?: string | undefined;
-    repoRef?: string | undefined;
-    workflow?: string | undefined;
 }>;
 export declare const GateSchema: z.ZodObject<{
     approve: z.ZodBoolean;
@@ -157,6 +158,10 @@ export interface RuntimeDeps {
     /** Run→operator-guidance index (CREW-UX-7) — `createServer` hydrates one from the audit trail
      *  so a restarted daemon still echoes `guidance`; a directly-driven route set gets a fresh one. */
     guidanceIndex?: GuidanceIndex;
+    /** Run→delivered-PR index (CREW-UX-8, crew#321) — `createServer` hydrates one from the audit
+     *  trail so a restarted daemon still echoes `delivery`; a directly-driven route set gets a
+     *  fresh one. */
+    deliveryIndex?: DeliveryIndex;
     openWithOs?: (target: string) => Promise<void>;
     /** Seat sign-in presence probe (seat sign-in) — injectable so route tests never read the
      *  developer's real dotfiles. Defaults to the file/env heuristic in seat-signin.ts. */

package/dist/api/routes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../../src/api/routes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAgB,MAAM,SAAS,CAAC;AAC7D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,OAAO,EAAwB,WAAW,EAAkD,MAAM,oBAAoB,CAAC;AAEvH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAMnD,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAWrD,OAAO,EAAyB,KAAK,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAEtF,OAAO,EAAe,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAInF,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAe,KAAK,QAAQ,EAAE,MAAM,WAAW,CAAC;AAGvD,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAyF7C;;;;;;;;;;;;GAYG;AAIH,eAAO,MAAM,YAAY;;;;;;;;IAQvB;+FAC2F;;IAE3F;;wFAEoF;;IAEpF;;0FAEsF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKtF,CAAC;AAEH,eAAO,MAAM,UAAU;;;;;;;;;EAGZ,CAAC;AAEZ;;yEAEyE;AACzE,eAAO,MAAM,cAAc;;;;;;EAEhB,CAAC;AAUZ,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;EAQpB,CAAC;AAOZ,4FAA4F;AAC5F,eAAO,MAAM,cAAc;;;;;;;;;EAGhB,CAAC;AAwBZ,sEAAsE;AACtE,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,QAAQ,CAAC;IAChB,QAAQ,EAAE,QAAQ,CAAC;CACpB;AAED;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC1B,UAAU,CAAC,EAAE,iBAAiB,CAAC;IAC/B;oGACgG;IAChG,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB;uGACmG;IACnG,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/C;2FACuF;IACvF,QAAQ,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,gBAAgB,CAAC,EAAE,MAAM,KAAK,OAAO,GAAG,IAAI,CAAC;IAC1E;;0DAEsD;IACtD,kBAAkB,CAAC,EAAE,qBAAqB,CAAC;CAC5C;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,GAAG,EAAE,eAAe,EACpB,OAAO,EAAE,WAAW,EACpB,SAAS,EAAE,SAAS,EACpB,gBAAgB,EAAE,gBAAgB,EAIlC,YAAY,GAAE,WAA+B,EAG7C,QAAQ,GAAE,iBAAqF,EAK/F,QAAQ,GAAE,YAA0D,EAGpE,OAAO,GAAE,WAAgB,GACxB,IAAI,CA+wDN"}
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../../src/api/routes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAgB,MAAM,SAAS,CAAC;AAC7D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,OAAO,EAAwB,WAAW,EAA4E,MAAM,oBAAoB,CAAC;AAEjJ,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAMnD,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAWrD,OAAO,EAAyB,KAAK,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAWtF,OAAO,EAAe,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAInF,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAe,KAAK,QAAQ,EAAE,MAAM,WAAW,CAAC;AAGvD,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAgG7C;;;;;;;;;;;;GAYG;AAIH,eAAO,MAAM,YAAY;;;;;;;;IAQvB;+FAC2F;;IAE3F;;wFAEoF;;IAEpF;;0FAEsF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKtF,CAAC;AAEH,eAAO,MAAM,UAAU;;;;;;;;;EAGZ,CAAC;AAEZ;;yEAEyE;AACzE,eAAO,MAAM,cAAc;;;;;;EAEhB,CAAC;AAUZ,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;EAQpB,CAAC;AAOZ,4FAA4F;AAC5F,eAAO,MAAM,cAAc;;;;;;;;;EAGhB,CAAC;AAwBZ,sEAAsE;AACtE,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,QAAQ,CAAC;IAChB,QAAQ,EAAE,QAAQ,CAAC;CACpB;AAED;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC1B,UAAU,CAAC,EAAE,iBAAiB,CAAC;IAC/B;oGACgG;IAChG,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB;uGACmG;IACnG,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B;;qBAEiB;IACjB,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/C;2FACuF;IACvF,QAAQ,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,gBAAgB,CAAC,EAAE,MAAM,KAAK,OAAO,GAAG,IAAI,CAAC;IAC1E;;0DAEsD;IACtD,kBAAkB,CAAC,EAAE,qBAAqB,CAAC;CAC5C;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,GAAG,EAAE,eAAe,EACpB,OAAO,EAAE,WAAW,EACpB,SAAS,EAAE,SAAS,EACpB,gBAAgB,EAAE,gBAAgB,EAIlC,YAAY,GAAE,WAA+B,EAG7C,QAAQ,GAAE,iBAAqF,EAK/F,QAAQ,GAAE,YAA0D,EAGpE,OAAO,GAAE,WAAgB,GACxB,IAAI,CAk+DN"}

package/dist/api/routes.js

@@ -5,7 +5,7 @@ import { readFileSync, existsSync } from 'node:fs';
 import { promises as fsp } from 'node:fs';
 import { isAbsolute, join, relative, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { ChatUnsupportedError, CoreAdapter, ElicitationUnsupportedError, humanGatePhaseIds } from '../core/adapter.js';
+import { ChatUnsupportedError, CoreAdapter, ElicitationUnsupportedError, SteeringUnsupportedError, humanGatePhaseIds } from '../core/adapter.js';
 import { codeGraphDb, requirementsGraph } from '../core/repoPaths.js';
 import { QeGateCache } from '../qe/gate-events.js';
 import { buildAcceptanceView, resolveRunWorkflow } from '../qe/acceptance.js';
@@ -18,6 +18,10 @@ import { allowedRootsFor, isInsideRoot, openWithSystemDefault } from './open-pat
 import { InvalidDiffBaseError, NotARegularFileError, UnresolvableDiffBaseError, readFileCapped, worktreeDiff, } from './run-files.js';
 import { resolveProjectGraphBinding } from '../projects/graph.js';
 import { registerProjectRoutes } from '../projects/routes.js';
+import { registerCampaignRoutes } from '../campaigns/routes.js';
+import { registerGovernanceWikiRoutes } from './governance-wiki.js';
+import { DEFAULT_STEERING_TYPE, STEERING_TYPE_VALUES, STEERING_TYPES, registerGovernanceSteeringRoutes, } from './governance-steering.js';
+import { registerTestingRoutes } from './testing.js';
 import { ProjectSettingsStore } from '../projects/settings.js';
 import { boundOrigin, InteractiveBridgePool } from '../interactive/bridge-pool.js';
 import { registerInteractiveProxy } from '../interactive/proxy-routes.js';
@@ -26,6 +30,7 @@ import { MEMBERSHIP_ATTACHED, membershipAttachedKey } from '../projects/events.j
 import { AuditLog } from './audit.js';
 import { RetryIndex } from './retry-index.js';
 import { GuidanceIndex } from './guidance-index.js';
+import { DeliveryIndex } from './delivery-index.js';
 import { LOCAL_ACTOR } from './auth.js';
 // Re-exported so existing `import { API_PREFIX } from './routes.js'` callers keep working; the
 // value lives in the leaf module api-prefix.ts to keep unit-output.ts out of this file's cycle.
@@ -73,6 +78,12 @@ function invalidBody(err, what) {
         : what;
     return { error, details: err.issues };
 }
+// Closed facet vocabularies for the `GET /governance/rules` browse filters (wiki-mgmt) — the
+// wire contract's `RuleBrowseQuery`. Sets, not zod: the query is otherwise free-form and only
+// these three facets have a vocabulary to enforce.
+const RULE_SEVERITIES = new Set(['info', 'warn', 'error', 'critical']);
+const RULE_TYPES = new Set(['pattern', 'policy']);
+const RULE_STATUSES = new Set(['active', 'retired', 'all']);
 // Repo names become directory components under ~/.wicked/repos/ — reject anything
 // that would allow path traversal (slashes, dots-only segments, control chars).
 const SAFE_REPO_NAME = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
@@ -217,10 +228,12 @@ runtime = {}) {
     const signedIn = runtime.signedIn ?? signedInHeuristic;
     const retryIndex = runtime.retryIndex ?? new RetryIndex();
     const guidanceIndex = runtime.guidanceIndex ?? new GuidanceIndex();
+    const deliveryIndex = runtime.deliveryIndex ?? new DeliveryIndex();
     // The run-DTO joins (DES-UX-001 §8.2/§8.3, DES-UX-002 §7.2): `project_id` from the membership
     // record — `null` = genuinely unfiled, so the field is ALWAYS present on served runs —
-    // `retry_of` from the lineage index, and `guidance` from the guidance index, each set only
-    // when known (absent, never null, spells "not a retry" / "no note").
+    // `retry_of` from the lineage index, `guidance` from the guidance index, and `delivery`
+    // from the delivery index (CREW-UX-8, crew#321), each set only when known (absent, never
+    // null, spells "not a retry" / "no note" / "delivered nothing").
     // Applied at DTO assembly on exactly the two endpoints that serve the run DTO
     // (GET /runs + GET /runs/:id); the internal sessionsDetail() consumers are untouched.
     const decorateRun = (view) => {
@@ -231,6 +244,9 @@ runtime = {}) {
         const guidance = guidanceIndex.guidanceFor(view.session.id);
         if (guidance !== undefined)
             view.session.guidance = guidance;
+        const delivery = deliveryIndex.deliveryFor(view.session.id);
+        if (delivery !== undefined)
+            view.session.delivery = delivery;
         return view;
     };
     // Resolved ONCE and shared by the project routes (which read/write `interactiveRoot`) and the
@@ -977,6 +993,12 @@ runtime = {}) {
             workflow,
             gateEvents: qeGateEvents,
             ...(qeRunId !== undefined && qeRunId !== '' ? { qeRunId } : {}),
+            // AW-14 (arch-R13a + R16): the conformance section reads the same wires the standalone
+            // `/governance/claims` and `/runs/:id/events` routes serve, but run-scoped and resolved
+            // deny-dominates BESIDE the QE gate — so a wiki-rule violation and an unenforced governed
+            // unit both appear on the page humans actually look at.
+            claims: () => adapter.listConformanceClaims(),
+            events: (rid) => adapter.runEvents(rid),
         });
     });
     // The steering gate (§11.1). approve+amend = approve-with-steer; approve:false = reject (cancels).
@@ -1312,12 +1334,92 @@ runtime = {}) {
         return { runId: id, total: events.length, returned: filtered.length, events: filtered };
     });
     // ── Governance reads (crew#40) ──────────────────────────────────────────────
-    app.get(`${V}/governance/policies`, async () => {
+    // STEERING fold: the READ half of the old policy surface stays — retired-not-deleted means a
+    // past gate decision citing a policy id must stay resolvable, and the engine keeps serving the
+    // listing (as a thin shim over the unified store once the model merges). The WRITE half
+    // (POST/DELETE below) answers 410 on a steering engine — see the fold comment there.
+    app.get(`${V}/governance/policies`, { config: { manifest: { responseType: '{ policies: GovernancePolicy[] }', statusCodes: [200] } } }, async () => {
         const policies = await adapter.listPolicies();
         return { policies };
     });
-    app.get(`${V}/governance/rules`, async () => {
-        const rules = await adapter.listConformanceRules();
+    // The wiki BROWSE surface (wiki-mgmt): facet filters over the listed rows. EXACT matches by
+    // design — unlike `/governance/rules/preview`, whose recall semantics treat an absent rule
+    // facet as a wildcard (enforcement's question: "which rules apply HERE"), browse answers
+    // "show me the rules TAGGED `layer=api`", and a wildcard rule flooding every layer filter
+    // would bury the tagged ones. `?status=` keeps the AW-24 kill switch visible: every row keeps
+    // its `retired` flag, and `retired`/`active` narrow to one side. Default is `all` — the
+    // route's historical behavior, though pre-0.7.4 addons funnel the listing through recall and
+    // return active rows only (the engine's fact to fix, not this filter's to mask).
+    app.get(`${V}/governance/rules`, {
+        config: {
+            manifest: {
+                responseType: '{ rules: ConformanceRule[] }',
+                // 501: `?type=` on a pre-steering engine (wicked-core-ts < 0.7.5) — see the facet below.
+                statusCodes: [200, 400, 501],
+            },
+        },
+    }, async (req, reply) => {
+        const q = req.query;
+        // Same normalization as `repoParam` below: first value of a repeated param, trimmed, and
+        // an empty/whitespace value means "facet not given" rather than a filter matching nothing.
+        const facet = (k) => {
+            const raw = q[k];
+            const first = Array.isArray(raw) ? raw[0] : raw;
+            const trimmed = first?.trim();
+            return trimmed ? trimmed : undefined;
+        };
+        // Closed vocabularies reject loudly (400 names the valid set): `?severity=hihg` silently
+        // matching nothing would read as "no critical rules" — an empty answer to a question the
+        // caller didn't ask.
+        const invalid = (name, got, valid) => reply.code(400).send({ error: `${name} must be one of ${valid} (got \`${got}\`)` });
+        const severity = facet('severity');
+        if (severity !== undefined && !RULE_SEVERITIES.has(severity)) {
+            return invalid('severity', severity, 'info|warn|error|critical');
+        }
+        const ruleType = facet('rule_type');
+        if (ruleType !== undefined && !RULE_TYPES.has(ruleType)) {
+            return invalid('rule_type', ruleType, 'pattern|policy');
+        }
+        // `?type=` — the STEERING facet (one Steering sub-page per type). Closed vocabulary, and
+        // presence-gated on the steering engine: rows served by a pre-0.7.5 addon carry no
+        // `steering_type`, so filtering them would answer "no <type> rules" to a question this
+        // engine cannot answer — 501 ("upgrade the engine"), never an empty non-answer.
+        const steeringType = facet('type');
+        if (steeringType !== undefined && !STEERING_TYPES.has(steeringType)) {
+            return invalid('type', steeringType, STEERING_TYPE_VALUES.join('|'));
+        }
+        if (steeringType !== undefined && !adapter.steeringSupported()) {
+            return reply
+                .code(501)
+                .send({ error: new SteeringUnsupportedError('Filtering rules by steering type').message });
+        }
+        // `?include_retired=` — the boolean spelling of the retire filter (`true` ⇒ `all`,
+        // `false` ⇒ `active`). Mutually exclusive with `?status=`: the two are one filter in two
+        // spellings, and silently picking a winner when they contradict would answer a question
+        // the caller didn't ask.
+        const includeRetired = facet('include_retired');
+        if (includeRetired !== undefined && includeRetired !== 'true' && includeRetired !== 'false') {
+            return invalid('include_retired', includeRetired, 'true|false');
+        }
+        const statusGiven = facet('status');
+        if (includeRetired !== undefined && statusGiven !== undefined) {
+            return reply.code(400).send({
+                error: 'send `status` or `include_retired`, not both — they are two spellings of the same retire filter and can contradict',
+            });
+        }
+        const status = statusGiven ?? (includeRetired === undefined ? 'all' : includeRetired === 'true' ? 'all' : 'active');
+        if (!RULE_STATUSES.has(status)) {
+            return invalid('status', status, 'active|retired|all');
+        }
+        const layer = facet('layer');
+        const rules = (await adapter.listConformanceRules()).filter((r) => (severity === undefined || r.severity === severity) &&
+            (ruleType === undefined || r.rule_type === ruleType) &&
+            (layer === undefined || r.targets.layer === layer) &&
+            // Absent `steering_type` reads as the engine's serde default (architecture) — a
+            // steering engine always stamps it, but filter defensively over mixed-era rows.
+            (steeringType === undefined || (r.steering_type ?? DEFAULT_STEERING_TYPE) === steeringType) &&
+            // `retired` is absent on rows written before the field existed, which read as active.
+            (status === 'all' || (status === 'retired') === (r.retired === true)));
         return { rules };
     });
     app.get(`${V}/governance/claims`, async () => {
@@ -1372,8 +1474,27 @@ runtime = {}) {
             return reply.code(repoReadStatus(msg)).send({ error: msg });
         }
     });
-    // ── Governance writes (crew#42) ────────────────────────────────────────────
-    app.post(`${V}/governance/policies`, async (req, reply) => {
+    // ── Governance writes (crew#42; STEERING fold) ─────────────────────────────
+    // The OLD policy WRITE surface, folded into the unified rules routes (STEERING program): on a
+    // steering engine (wicked-core-ts ≥ 0.7.5, where policy rows have MIGRATED into steering
+    // rules) these answer 410 Gone with a pointer at the rules CRUD — the wire contract's honest
+    // spelling of "this resource model no longer exists" (a silent alias would accept a write into
+    // a store decide()/select() no longer read). On a PRE-steering engine the legacy behavior
+    // stands untouched: folding before the model merges would strand policy writes with no unified
+    // store to land in.
+    //
+    // The READ (`GET /governance/policies` above) deliberately stays: retired-not-deleted means
+    // past decisions citing a policy id must stay resolvable, the engine keeps a read shim for
+    // exactly that, and the released studio 0.4.2 still renders the listing.
+    const policyWriteGone = (reply, pointer) => reply.code(410).send({
+        error: 'the policy model merged into steering rules (STEERING program): policies are now ' +
+            `steering rules with effect/trigger/obligations/criteria as first-class fields — use ${pointer}`,
+        see: pointer,
+    });
+    app.post(`${V}/governance/policies`, { config: { manifest: { statusCodes: [200, 400, 410] } } }, async (req, reply) => {
+        if (adapter.steeringSupported()) {
+            return policyWriteGone(reply, `POST ${V}/governance/rules`);
+        }
         try {
             const policy = req.body;
             await adapter.upsertPolicy(policy);
@@ -1384,9 +1505,44 @@ runtime = {}) {
             return reply.code(400).send({ error: message(err) });
         }
     });
-    app.post(`${V}/governance/rules`, async (req, reply) => {
+    // The steering fields a rule write may carry — the merged model's additions (STEERING). On an
+    // engine that predates the model, `upsertConformanceRule` would ACCEPT the write and silently
+    // drop every one of them (ConformanceRule has no `deny_unknown_fields`), persisting a rule
+    // that recalls and enforces differently than the caller wrote — so their presence is gated
+    // loudly (the extraWriteRoots doctrine): 501, upgrade the engine. A write WITHOUT them is the
+    // legacy request and passes through on any engine.
+    const STEERING_RULE_FIELDS = [
+        'steering_type',
+        'applies_to',
+        'excludes',
+        'weight',
+        'effect',
+        'trigger',
+        'obligations',
+        'criteria',
+    ];
+    app.post(`${V}/governance/rules`, {
+        config: {
+            manifest: {
+                requestType: 'ConformanceRule',
+                // 501: the body carries steering fields but the installed engine predates the
+                // steering model (wicked-core-ts < 0.7.5) and would silently drop them.
+                statusCodes: [200, 400, 501],
+            },
+        },
+    }, async (req, reply) => {
         try {
             const rule = req.body;
+            if (!adapter.steeringSupported() && rule !== null && typeof rule === 'object') {
+                const carried = STEERING_RULE_FIELDS.filter((f) => rule[f] !== undefined);
+                if (carried.length > 0) {
+                    return reply.code(501).send({
+                        error: `${new SteeringUnsupportedError('Writing steering rule fields').message} — ` +
+                            `the installed engine would silently drop ${carried.map((f) => `\`${f}\``).join(', ')} ` +
+                            'and persist a rule that enforces differently than you wrote',
+                    });
+                }
+            }
             await adapter.upsertConformanceRule(rule);
             audit.record('governance.rule.upserted', actorOf(req), { detail: { id: rule?.id } });
             return { status: 'ok' };
@@ -1397,8 +1553,13 @@ runtime = {}) {
     });
     // Retire, not delete. The record survives so past decisions citing it stay explicable; it just
     // stops being enforced (FINDING-038 — a mis-authored policy otherwise denied forever).
-    app.delete(`${V}/governance/policies/:id`, async (req, reply) => {
+    app.delete(`${V}/governance/policies/:id`, { config: { manifest: { statusCodes: [200, 400, 404, 410] } } }, async (req, reply) => {
         const { id } = req.params;
+        // Folded like the POST above: on a steering engine the migrated row retires through the
+        // rules kill switch (same id — migration keeps ids stable so decision audits resolve).
+        if (adapter.steeringSupported()) {
+            return policyWriteGone(reply, `DELETE ${V}/governance/rules/${id}`);
+        }
         try {
             const existed = await adapter.retirePolicy(id);
             if (!existed)
@@ -1921,6 +2082,31 @@ runtime = {}) {
     });
     // ── Projects (DES-PROJECT-001) — the 9-route experience-plane surface ────────
     registerProjectRoutes(app, adapter, { ...projects, settings: projectSettings }, security);
+    // ── Campaigns (crew#342 + TH-9) — the engine's durable Run-DAG scheduler over REST ──────────
+    // Progress streams as campaign* CoreEvents on the existing allowlist-free /ws relay; these
+    // routes are launch/resume/cancel + the reads a scoreboard builds from.
+    registerCampaignRoutes(app, adapter, {
+        audit,
+        actorOf,
+        roster: () => CoreAdapter.roster(),
+    });
+    // ── Governance wiki management (wiki-mgmt) — scoreboard + honest empty-state meta ──────────
+    // Browse (`GET /governance/rules` + facets) and retire (`DELETE /governance/rules/:id`) stay
+    // ABOVE with the other governance routes; this registers only the wiki-specific reads.
+    // Both wiki reads feed the Steering page header too — they stay, unchanged (STEERING).
+    registerGovernanceWikiRoutes(app, adapter);
+    // ── Steering management (STEERING program) — batch import + "add with chat" authoring ──────
+    // Per-rule CRUD stays ABOVE with the other governance routes (a steering rule IS a
+    // conformance rule); this registers only the import batch and the governed authoring launch.
+    registerGovernanceSteeringRoutes(app, adapter, {
+        audit,
+        actorOf,
+        roster: () => CoreAdapter.roster(),
+    });
+    // ── Testing (crew-testing) — governance evals + eval corpora ────────────────
+    // Run the evals (does the steering corpus catch what it claims to?) and import a named eval
+    // corpus. Both presence-gated on the engine's evals bindings (501 on wicked-core-ts < 0.7.5).
+    registerTestingRoutes(app, adapter, { audit, actorOf });
     // ── The wicked-interactive bridge, reverse-proxied (DES-MERGE-001 §5.3/§7.2) ──
     // Mounted BESIDE the routes above and under the same `${V}` prefix, so it inherits one
     // origin, one auth hook, and one CORS posture — the whole point of slice 1.