@ikon85/agent-workflow-kit 0.36.5 → 0.38.0

package/scripts/project-skill-extension.mjs

@@ -1,7 +1,11 @@
 #!/usr/bin/env node
-import { resolve } from 'node:path';
+import { readFile } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { inspectProjectSkillExtension } from '../src/lib/projectSkillExtension.mjs';
+import { readComposedSkillRegistry } from '../src/lib/skillRegistry.mjs';
+
+const CORE_REGISTRY = '.claude/skills/skill-manifest.json';
 
 function argumentsFor(argv) {
   const args = [...argv];
@@ -23,7 +27,22 @@ function argumentsFor(argv) {
 
 export async function main(argv = process.argv.slice(2)) {
   const options = argumentsFor(argv);
-  return inspectProjectSkillExtension(options);
+  let activation;
+  try {
+    const core = JSON.parse(await readFile(join(options.root, CORE_REGISTRY), 'utf8'));
+    const registry = await readComposedSkillRegistry(options.root, core);
+    const matches = Object.values(registry.readiness?.capabilities ?? {})
+      .map((capability) => capability?.evidence)
+      .filter((evidence) =>
+        evidence?.type === 'project-extension' && evidence.skill === options.skill);
+    if (matches.length > 1) {
+      throw new Error(`multiple Project extension activation policies for ${options.skill}`);
+    }
+    activation = matches[0]?.activation;
+  } catch (error) {
+    if (error.code !== 'ENOENT') throw error;
+  }
+  return inspectProjectSkillExtension({ ...options, activation });
 }
 
 if (process.argv[1] === fileURLToPath(import.meta.url)) {

package/scripts/readiness.mjs

@@ -4,6 +4,7 @@ import { join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { firstLineState } from '../src/lib/sentinel.mjs';
 import { CONSUMER_MANIFEST_NAME, readManifest, writeManifest } from '../src/lib/manifest.mjs';
+import { inspectProjectSkillExtension } from '../src/lib/projectSkillExtension.mjs';
 import { readComposedSkillRegistry } from '../src/lib/skillRegistry.mjs';
 
 const SOURCE_MANIFEST = '.claude/skills/skill-manifest.json';
@@ -87,6 +88,19 @@ async function runbookVerdict(root, evidence) {
   return 'invalid';
 }
 
+async function projectExtensionVerdict(root, evidence) {
+  try {
+    const result = await inspectProjectSkillExtension({
+      root,
+      skill: evidence.skill,
+      activation: evidence.activation,
+    });
+    return { verdict: result.state === 'active' ? 'valid' : 'absent' };
+  } catch (error) {
+    return { verdict: 'invalid', blocking: true, diagnostic: error.message };
+  }
+}
+
 function section(text, heading) {
   if (text === null) return null;
   const lines = text.split('\n');
@@ -148,6 +162,7 @@ async function prodEvidence(root, paths) {
 async function evidenceVerdict(root, evidence) {
   if (evidence.type === 'prod-section') return (await prodEvidence(root, evidence.paths)).verdict;
   if (evidence.type === 'runbook-reference') return runbookVerdict(root, evidence);
+  if (evidence.type === 'project-extension') return projectExtensionVerdict(root, evidence);
   const verdicts = await Promise.all((evidence.paths ?? []).map(async (path) => {
     const text = await readText(root, path);
     if (evidence.type === 'sentinel') return sentinelVerdict(text, evidence.allowLegacy);
@@ -163,9 +178,19 @@ async function evidenceVerdict(root, evidence) {
 export async function evaluateCapability({ root, capability, decision }) {
   const prod = capability.evidence.type === 'prod-section'
     ? await prodEvidence(root, capability.evidence.paths) : null;
-  const evidence = prod?.verdict ?? await evidenceVerdict(root, capability.evidence);
-  const diagnostics = prod?.diagnostics?.length ? { diagnostics: prod.diagnostics } : {};
-  if (evidence === 'invalid') return { state: 'invalid', clearDecision: false, ...diagnostics };
+  const evaluated = prod ?? await evidenceVerdict(root, capability.evidence);
+  const evidence = typeof evaluated === 'string' ? evaluated : evaluated.verdict;
+  const diagnostics = evaluated?.diagnostics?.length
+    ? { diagnostics: evaluated.diagnostics }
+    : (evaluated?.diagnostic ? { diagnostic: evaluated.diagnostic } : {});
+  if (evidence === 'invalid') {
+    return {
+      state: 'invalid',
+      clearDecision: false,
+      ...(evaluated?.blocking ? { blocking: true } : {}),
+      ...diagnostics,
+    };
+  }
   if (evidence === 'valid') return { state: 'ready', clearDecision: Boolean(decision) };
   if (decision === 'pending') return { state: 'pending', clearDecision: false, ...diagnostics };
   if (decision === 'not-applicable' && capability.allowNotApplicable) {
@@ -206,7 +231,10 @@ export async function checkSkill({ root, skill, manifest }) {
     (capabilities[name].state === 'ready' ? activeBlocks : inactiveBlocks).push(block);
   }
   const invalid = Object.values(capabilities).some(({ state }) => state === 'invalid');
-  const verdict = requiredBlocked ? 'blocked' : (inactiveBlocks.length || invalid ? 'degraded' : 'ready');
+  const fatal = Object.values(capabilities).some(({ blocking }) => blocking === true);
+  const verdict = requiredBlocked || fatal
+    ? 'blocked'
+    : (inactiveBlocks.length || invalid ? 'degraded' : 'ready');
   return { contractVersion: manifest.readiness.contractVersion, verdict, capabilities, activeBlocks, inactiveBlocks };
 }
 

package/scripts/release-state.mjs

@@ -8,11 +8,21 @@ import { fileURLToPath } from 'node:url';
 import { assertReleaseParity, releaseIdentityFromTarball } from './release-parity.mjs';
 
 const exec = promisify(execFile);
+export const DEFAULT_VISIBILITY_DELAYS_MS = Object.freeze([
+  1_000,
+  2_000,
+  4_000,
+  8_000,
+  16_000,
+  32_000,
+  64_000,
+  128_000,
+  256_000,
+]);
 const DEFAULT_VISIBILITY = {
-  attempts: 6,
-  initialDelayMs: 1_000,
-  backoffFactor: 2,
+  delaysMs: DEFAULT_VISIBILITY_DELAYS_MS,
   sleep,
+  log: console.log,
 };
 
 const assertMatches = (local, remote, label) => assertReleaseParity({
@@ -37,18 +47,18 @@ export async function inspectRelease(adapter) {
 
 async function awaitVisibility(read, phase, options = {}) {
   const policy = { ...DEFAULT_VISIBILITY, ...options };
-  let delay = policy.initialDelayMs;
-  for (let attempt = 1; attempt <= policy.attempts; attempt += 1) {
+  const attempts = policy.delaysMs.length + 1;
+  for (let attempt = 1; attempt <= attempts; attempt += 1) {
+    policy.log(`${phase.service} visibility: attempt ${attempt}/${attempts}`);
     const visible = await read();
     if (visible) return visible;
-    if (attempt < policy.attempts) {
-      await policy.sleep(delay);
-      delay *= policy.backoffFactor;
+    if (attempt < attempts) {
+      await policy.sleep(policy.delaysMs[attempt - 1]);
     }
   }
   throw new Error(
     `${phase.operation} succeeded but ${phase.subject} was not visible `
-    + `after ${policy.attempts} ${phase.service} read attempts`,
+    + `after ${attempts} ${phase.service} read attempts`,
   );
 }
 

package/scripts/release-state.test.mjs

@@ -7,8 +7,8 @@ import { dirname, join } from 'node:path';
 import { tmpdir } from 'node:os';
 import { fileURLToPath } from 'node:url';
 import {
-  createCommandAdapter, githubReleaseArgs, inspectRelease, isMissingRelease,
-  npmTarballFilename, reconcileRelease,
+  createCommandAdapter, DEFAULT_VISIBILITY_DELAYS_MS, githubReleaseArgs, inspectRelease,
+  isMissingRelease, npmTarballFilename, reconcileRelease,
 } from './release-state.mjs';
 
 const REPO = join(dirname(fileURLToPath(import.meta.url)), '..');
@@ -26,6 +26,7 @@ function adapter({
   githubInvisibleReads = 0,
   publishNpmError,
   createGithubError,
+  npmReadErrorAfterPublish,
 } = {}) {
   const events = [];
   let npmExists = npmPublished;
@@ -38,6 +39,7 @@ function adapter({
     npm: async () => {
       events.push('read npm');
       if (!npmExists) return null;
+      if (npmReadErrorAfterPublish) throw npmReadErrorAfterPublish;
       if (npmReadsUntilVisible > 0) {
         npmReadsUntilVisible -= 1;
         return null;
@@ -66,17 +68,25 @@ function adapter({
   };
 }
 
-function visibilityOptions(attempts, delays = []) {
+function visibilityOptions(attempts, delays = [], progress = []) {
   return {
     visibility: {
-      attempts,
-      initialDelayMs: 10,
-      backoffFactor: 2,
+      delaysMs: Array.from({ length: attempts - 1 }, (_, index) => 10 * (2 ** index)),
       sleep: async (delay) => delays.push(delay),
+      log: (message) => progress.push(message),
     },
   };
 }
 
+test('the default npm visibility window spans at least five minutes', () => {
+  assert.ok(
+    DEFAULT_VISIBILITY_DELAYS_MS.reduce((total, delay) => total + delay, 0) >= 300_000,
+  );
+  assert.deepEqual(DEFAULT_VISIBILITY_DELAYS_MS, [
+    1_000, 2_000, 4_000, 8_000, 16_000, 32_000, 64_000, 128_000, 256_000,
+  ]);
+});
+
 test('a fresh release publishes npm, verifies registry readback, then creates GitHub release', async () => {
   const fixture = adapter();
   assert.deepEqual(await reconcileRelease(fixture), { status: 'released', identity });
@@ -88,8 +98,9 @@ test('a fresh release publishes npm, verifies registry readback, then creates Gi
 test('npm visibility is retried with bounded backoff after a successful publish', async () => {
   const fixture = adapter({ npmInvisibleReads: 2 });
   const delays = [];
+  const progress = [];
   assert.deepEqual(
-    await reconcileRelease(fixture, visibilityOptions(4, delays)),
+    await reconcileRelease(fixture, visibilityOptions(4, delays, progress)),
     { status: 'released', identity },
   );
   assert.deepEqual(fixture.events, [
@@ -98,6 +109,12 @@ test('npm visibility is retried with bounded backoff after a successful publish'
     'create github', 'read github',
   ]);
   assert.deepEqual(delays, [10, 20]);
+  assert.deepEqual(progress, [
+    'npm visibility: attempt 1/4',
+    'npm visibility: attempt 2/4',
+    'npm visibility: attempt 3/4',
+    'GitHub visibility: attempt 1/4',
+  ]);
 });
 
 test('GitHub visibility is retried with bounded backoff after a successful create', async () => {
@@ -116,11 +133,17 @@ test('GitHub visibility is retried with bounded backoff after a successful creat
 test('permanent npm absence fails at the bound with post-publish phase evidence', async () => {
   const fixture = adapter({ npmInvisibleReads: 4 });
   const delays = [];
+  const progress = [];
   await assert.rejects(
-    reconcileRelease(fixture, visibilityOptions(3, delays)),
+    reconcileRelease(fixture, visibilityOptions(3, delays, progress)),
     /npm publish succeeded but package was not visible after 3 npm read attempts/,
   );
   assert.deepEqual(delays, [10, 20]);
+  assert.deepEqual(progress, [
+    'npm visibility: attempt 1/3',
+    'npm visibility: attempt 2/3',
+    'npm visibility: attempt 3/3',
+  ]);
   assert.equal(fixture.events.filter((event) => event === 'read npm').length, 4);
   assert.ok(!fixture.events.includes('create github'));
 });
@@ -158,6 +181,14 @@ test('an npm-published release resumes at GitHub without a second npm publish',
   assert.ok(!fixture.events.includes('publish npm'));
 });
 
+test('a rerun after eventual npm visibility never publishes the version twice', async () => {
+  const fixture = adapter({ npmInvisibleReads: 2 });
+  await reconcileRelease(fixture, visibilityOptions(4));
+  await reconcileRelease(fixture, visibilityOptions(4));
+  assert.equal(fixture.events.filter((event) => event === 'publish npm').length, 1);
+  assert.equal(fixture.events.filter((event) => event === 'create github').length, 1);
+});
+
 test('an already-published release at parity is a read-only no-op', async () => {
   const fixture = adapter({ npmPublished: true, githubReleased: true });
   assert.deepEqual(await reconcileRelease(fixture), { status: 'released', identity });
@@ -256,6 +287,38 @@ test('a mismatching npm package blocks GitHub release creation', async () => {
   assert.ok(!fixture.events.includes('create github'));
 });
 
+test('a post-publish npm mismatch hard-stops without retrying or creating GitHub', async () => {
+  const fixture = adapter({
+    npmIdentity: { ...identity, manifestSha256: 'wrong' },
+  });
+  const delays = [];
+  const progress = [];
+  await assert.rejects(
+    reconcileRelease(fixture, visibilityOptions(4, delays, progress)),
+    /npm manifestSha256 mismatch/,
+  );
+  assert.deepEqual(delays, []);
+  assert.deepEqual(progress, ['npm visibility: attempt 1/4']);
+  assert.equal(fixture.events.filter((event) => event === 'publish npm').length, 1);
+  assert.equal(fixture.events.filter((event) => event === 'read npm').length, 2);
+  assert.ok(!fixture.events.includes('create github'));
+});
+
+test('a post-publish non-missing registry error hard-stops without retrying', async () => {
+  const registryError = new Error('registry authentication failed');
+  const fixture = adapter({ npmReadErrorAfterPublish: registryError });
+  const delays = [];
+  const progress = [];
+  await assert.rejects(
+    reconcileRelease(fixture, visibilityOptions(4, delays, progress)),
+    (error) => error === registryError,
+  );
+  assert.deepEqual(delays, []);
+  assert.deepEqual(progress, ['npm visibility: attempt 1/4']);
+  assert.equal(fixture.events.filter((event) => event === 'publish npm').length, 1);
+  assert.ok(!fixture.events.includes('create github'));
+});
+
 test('release workflow uses supported OIDC trusted publishing without a long-lived npm token', async () => {
   const workflow = await readFile(join(REPO, '.github/workflows/release.yml'), 'utf8');
   assert.match(workflow, /node-version:\s*22\.14/);

package/scripts/test_anchor_table.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python3
+"""Focused regression tests for pure anchor-table status decisions."""
+
+from __future__ import annotations
+
+import unittest
+
+from scripts.anchor_table import refresh_status_cell, status_token_from_board
+
+
+ROLES = {
+    "inProgress": "In Progress",
+    "review": "In Review",
+    "done": "Done",
+}
+
+
+class AnchorTableStatusTest(unittest.TestCase):
+    def test_closed_done_issue_without_pr_is_done(self):
+        entry = {"state": "closed", "status": "Done", "prs": []}
+
+        self.assertEqual(status_token_from_board(entry, ROLES), "✅")
+
+    def test_open_issue_without_pr_is_never_done(self):
+        cases = (
+            ({"state": "open", "status": "Done", "prs": []}, "⬜"),
+            ({"state": "open", "status": "In Progress", "prs": []}, "🔄"),
+        )
+
+        for entry, expected in cases:
+            with self.subTest(status=entry["status"]):
+                self.assertEqual(status_token_from_board(entry, ROLES), expected)
+
+    def test_merged_pr_keeps_numbered_done_token(self):
+        entry = {
+            "state": "closed",
+            "status": "Done",
+            "prs": [{"state": "MERGED", "number": 203}],
+        }
+
+        self.assertEqual(status_token_from_board(entry, ROLES), "✅ #203")
+
+    def test_refresh_never_regresses_existing_progress(self):
+        open_unstarted = {"state": "open", "status": "To Do", "prs": []}
+
+        self.assertEqual(
+            refresh_status_cell("✅ spike proven", open_unstarted, ROLES),
+            "✅ spike proven",
+        )
+        self.assertEqual(
+            refresh_status_cell("🔄 spike running", open_unstarted, ROLES),
+            "🔄 spike running",
+        )
+        self.assertEqual(
+            refresh_status_cell("✅ #199", open_unstarted, ROLES),
+            "✅ #199",
+        )
+
+    def test_refresh_advances_to_prless_done(self):
+        closed_done = {"state": "closed", "status": "Done", "prs": []}
+
+        self.assertEqual(
+            refresh_status_cell("🔄 spike running", closed_done, ROLES),
+            "✅",
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()

package/scripts/test_board_sync_create_idempotency.py

@@ -34,6 +34,7 @@ PROFILE = {
 
 
 def load_board_sync():
+    previous_profile = os.environ.get("BOARD_SYNC_PROFILE")
     with tempfile.NamedTemporaryFile("w", suffix=".md", delete=False) as profile:
         profile.write("<!-- board-sync:profile -->\n```json\n")
         json.dump(PROFILE, profile)
@@ -45,11 +46,18 @@ def load_board_sync():
     )
     module = importlib.util.module_from_spec(spec)
     assert spec.loader is not None
-    spec.loader.exec_module(module)
-    Path(profile_path).unlink()
+    try:
+        spec.loader.exec_module(module)
+    finally:
+        Path(profile_path).unlink()
+        if previous_profile is None:
+            os.environ.pop("BOARD_SYNC_PROFILE", None)
+        else:
+            os.environ["BOARD_SYNC_PROFILE"] = previous_profile
     return module
 
 
+PROFILE_BEFORE_LOAD = os.environ.get("BOARD_SYNC_PROFILE")
 bs = load_board_sync()
 
 
@@ -80,6 +88,11 @@ class FakeGh:
         return ""
 
 
+class BoardSyncImportIsolationTest(unittest.TestCase):
+    def test_loading_board_sync_restores_the_caller_profile(self):
+        self.assertEqual(os.environ.get("BOARD_SYNC_PROFILE"), PROFILE_BEFORE_LOAD)
+
+
 class MarkerAwareCreateTest(unittest.TestCase):
     def test_identical_program_leaf_retry_reuses_existing_issue(self):
         marker = "<!-- program-leaf-source: program-x/1a -->"

package/scripts/test_board_sync_wave_title.py

@@ -37,6 +37,7 @@ BASE_PROFILE = {
 
 
 def load_board_sync(profile_dict: dict, module_name: str):
+    previous_profile = os.environ.get("BOARD_SYNC_PROFILE")
     with tempfile.NamedTemporaryFile("w", suffix=".md", delete=False) as profile:
         profile.write("<!-- board-sync:profile -->\n```json\n")
         json.dump(profile_dict, profile)
@@ -48,8 +49,14 @@ def load_board_sync(profile_dict: dict, module_name: str):
     )
     module = importlib.util.module_from_spec(spec)
     assert spec.loader is not None
-    spec.loader.exec_module(module)
-    Path(profile_path).unlink()
+    try:
+        spec.loader.exec_module(module)
+    finally:
+        Path(profile_path).unlink()
+        if previous_profile is None:
+            os.environ.pop("BOARD_SYNC_PROFILE", None)
+        else:
+            os.environ["BOARD_SYNC_PROFILE"] = previous_profile
     return module
 
 
@@ -75,6 +82,11 @@ class WaveTitleDefaultPrefix(unittest.TestCase):
             "Welle 29 — Auth hardening",
         )
 
+    def test_loading_board_sync_restores_the_caller_profile(self):
+        before = os.environ.get("BOARD_SYNC_PROFILE")
+        load_board_sync(copy.deepcopy(BASE_PROFILE), "board_sync_wave_isolation")
+        self.assertEqual(os.environ.get("BOARD_SYNC_PROFILE"), before)
+
 
 class WaveTitleProfilePrefix(unittest.TestCase):
     """A profile with `titles.wavePrefix` drives the anchor title language."""

package/scripts/test_census_backstop.py

@@ -40,6 +40,39 @@ class CensusBackstopTest(unittest.TestCase):
             "overrides": overrides or [],
         }) + "\n", encoding="utf-8")
 
+    def test_execute_ready_missing_profile_failure_is_captured_and_exact(self):
+        missing_profile = ROOT / "missing-board-profile.md"
+        environment = os.environ.copy()
+        environment["BOARD_SYNC_PROFILE"] = str(missing_profile)
+
+        completed = subprocess.run(
+            [
+                sys.executable,
+                str(ROOT / "scripts" / "execute-ready-check.py"),
+                "--issue",
+                "52",
+                "--mode",
+                "handoff",
+            ],
+            cwd=ROOT,
+            env=environment,
+            capture_output=True,
+            text=True,
+        )
+
+        expected_stderr = (
+            "[FAIL] execute-ready-check: Board-Profil nicht verfügbar — "
+            f"board profile not found at {missing_profile} — run /setup-workflow "
+            "to seed docs/agents/board-sync.md.\n"
+        )
+        diagnostics = (
+            f"stdout:\n{completed.stdout}\n"
+            f"stderr:\n{completed.stderr}"
+        )
+        self.assertEqual(completed.returncode, 1, diagnostics)
+        self.assertEqual(completed.stdout, "", diagnostics)
+        self.assertEqual(completed.stderr, expected_stderr, diagnostics)
+
     def activate_current(self, root):
         fresh = DRIFT_GUARD.scan_census_status(root)["fresh"]
         (root / ".census" / "active.json").write_text(

package/scripts/test_orchestrate_wave_contract.py

@@ -95,6 +95,15 @@ BEHAVIORAL_PARITY = {
         "Program-PRD",
         "program sync",
     ),
+    "session-owned teardown": (
+        "session.py begin",
+        "session.py create",
+        "refuses reused/pre-existing targets",
+        "seal the receipt",
+        "compare-deleted",
+        "foreign targets",
+        "recovery-OID evidence",
+    ),
     "program authorization continuity": (
         "explicit whole-Program mandate",
         "all planned Waves",
@@ -210,6 +219,41 @@ class OrchestrateWaveContract(unittest.TestCase):
         ):
             self.assertIn(fragment, done)
 
+    def test_phase_one_orders_producers_before_surface_measurers(self):
+        prose = " ".join(self.skill.split())
+        phase_one = prose.split("## Phase 1", 1)[1].split("## Phase 2", 1)[0]
+        for fragment in (
+            "Producer/measurer coupling",
+            "semantic dependency",
+            "measurer strictly after the producer",
+            "baseline reconciliation",
+            "drop producer-resolved entries",
+        ):
+            self.assertIn(fragment, phase_one)
+
+        done = phase_one.split("**Done when:**", 1)[1]
+        for fragment in (
+            "producer/measurer pair",
+            "explicit edge/order",
+            "reconciliation owner",
+        ):
+            self.assertIn(fragment, done)
+
+    def test_phase_four_centrally_runs_builder_browser_specs_before_ci(self):
+        prose = " ".join(self.skill.split())
+        phase_four = prose.split("## Phase 4", 1)[1].split("## Phase 5", 1)[0]
+        browser_contract = "builders authored or changed browser specs"
+        central_gate = "Re-run your project's full CI/verify gate CENTRALLY yourself"
+        for fragment in (
+            browser_contract,
+            "unverified artifact",
+            "ONE central green run",
+            "if `§Verify Recipe` names a local e2e runner",
+            "Never invent a command under generic fallback",
+        ):
+            self.assertIn(fragment, phase_four)
+        self.assertLess(phase_four.index(browser_contract), phase_four.index(central_gate))
+
     def test_phase_two_keeps_per_slice_routing_decisions(self):
         prose = " ".join(self.skill.split())
         self.assertIn("(a) inline vs delegate", prose)

package/scripts/test_retro_wrapup_contract.py

@@ -88,7 +88,7 @@ class WrapupChainingContract(unittest.TestCase):
         required = (
             "invoke the `retro` skill immediately in this run",
             "land nothing in this run",
-            "fresh explicit `/wrapup` invocation",
+            "fresh explicit `$wrapup` or `/wrapup` invocation",
         )
         for surface in SURFACES:
             with self.subTest(surface=surface):
@@ -120,10 +120,27 @@ class WrapupChainingContract(unittest.TestCase):
             with self.subTest(surface=surface):
                 text = skill(surface, "wrapup")
                 self.assertIn("disable-model-invocation: true", text)
-                self.assertIn("user's `/wrapup` input IS the explicit", text)
+                self.assertIn(
+                    "user's direct `$wrapup` or `/wrapup` input IS the explicit",
+                    text,
+                )
                 self.assertIn("program-sync", text)
                 self.assertIn("Phasen-Gates", text)
 
+    def test_wrapup_accepts_only_direct_user_dollar_or_slash_invocations(self):
+        required = (
+            "direct `$wrapup` or `/wrapup`",
+            "Natural-language requests",
+            "indirect skill chaining",
+            "autonomous invocation",
+            "fresh explicit `$wrapup` or `/wrapup` invocation",
+        )
+        for surface in SURFACES:
+            with self.subTest(surface=surface):
+                text = contract_text(surface, "wrapup")
+                for phrase in required:
+                    self.assertIn(phrase, text)
+
     def test_new_contract_is_reference_free(self):
         for surface in SURFACES:
             with self.subTest(surface=surface):