@delorenj/pjangler 1.2.19 → 1.2.25

package/templates/commonproject/tests/test_provision_bmad_skills.py

@@ -0,0 +1,203 @@
+from __future__ import annotations
+
+import importlib.util
+import json
+import os
+import shutil
+import stat
+import tempfile
+import unittest
+from contextlib import contextmanager
+from pathlib import Path
+
+
+ROOT = Path(__file__).parents[1]
+SCRIPT = ROOT / "template" / ".mise" / "scripts" / "provision-bmad-skills.py"
+SPEC = importlib.util.spec_from_file_location("provision_bmad_skills", SCRIPT)
+assert SPEC is not None and SPEC.loader is not None
+PROVISIONER = importlib.util.module_from_spec(SPEC)
+SPEC.loader.exec_module(PROVISIONER)
+
+
+@contextmanager
+def working_directory(path: Path):
+    previous = Path.cwd()
+    os.chdir(path)
+    try:
+        yield
+    finally:
+        os.chdir(previous)
+
+
+def snapshot(path: Path):
+    try:
+        mode = path.lstat().st_mode
+    except FileNotFoundError:
+        return ("missing",)
+    permissions = stat.S_IMODE(mode)
+    if stat.S_ISLNK(mode):
+        return ("symlink", permissions, os.readlink(path))
+    if stat.S_ISREG(mode):
+        return ("file", permissions, path.read_bytes())
+    if stat.S_ISDIR(mode):
+        return (
+            "directory",
+            permissions,
+            tuple((child.name, snapshot(child)) for child in sorted(path.iterdir())),
+        )
+    return ("special", permissions)
+
+
+class ProvisionTransactionTests(unittest.TestCase):
+    def setUp(self) -> None:
+        source = os.environ.get("PJ_BMAD_PACK_ROOT")
+        if not source:
+            self.skipTest("PJ_BMAD_PACK_ROOT must identify the canonical candidate pack")
+        self.temporary = tempfile.TemporaryDirectory(prefix="commonproject-bmad-transaction-")
+        self.root = Path(self.temporary.name)
+        self.pack = self.root / "pack"
+        shutil.copytree(source, self.pack, symlinks=True)
+        self.project = self.root / "project"
+        skills = self.project / ".agents" / "skills"
+        skills.mkdir(parents=True)
+        manifest = self.project / ".agents" / "skills.json"
+        private = skills / "bmad-private-custom"
+        private.mkdir()
+        (private / "SKILL.md").write_text("private custom must survive\n")
+        manifest.write_text(
+            json.dumps(
+                {
+                    "skills": [
+                        {"name": "custom", "source": "file:///custom"},
+                        {"name": "bmad-private-custom", "source": private.as_uri()},
+                        {"name": "bmad-stale", "source": (self.pack / "bmad-stale").as_uri()},
+                    ]
+                }
+            )
+            + "\n"
+        )
+        manifest.chmod(0o600)
+        copied = skills / "bmad-agent-pm"
+        copied.mkdir()
+        (copied / "legacy.txt").write_text("preserve exactly\n")
+        (skills / "bmad-agent-analyst").symlink_to(
+            self.pack / "bmad-agent-analyst", target_is_directory=True
+        )
+        (skills / "bmad-stale").symlink_to(
+            self.pack / "bmad-stale", target_is_directory=True
+        )
+        custom = skills / "custom"
+        custom.mkdir()
+        (custom / "SKILL.md").write_text("custom\n")
+        self.previous_pack = os.environ.get("PJ_BMAD_PACK_ROOT")
+        os.environ["PJ_BMAD_PACK_ROOT"] = str(self.pack)
+
+    def tearDown(self) -> None:
+        if self.previous_pack is None:
+            os.environ.pop("PJ_BMAD_PACK_ROOT", None)
+        else:
+            os.environ["PJ_BMAD_PACK_ROOT"] = self.previous_pack
+        self.temporary.cleanup()
+
+    def test_nth_link_failure_restores_exact_project_state(self) -> None:
+        before = snapshot(self.project)
+
+        def fail_fifth(target: Path, link: Path, index: int) -> None:
+            if index == 5:
+                raise OSError("injected fifth-link failure")
+            link.symlink_to(target, target_is_directory=True)
+
+        with working_directory(self.project):
+            with self.assertRaisesRegex(OSError, "fifth-link"):
+                PROVISIONER.provision(create_link=fail_fifth)
+
+        self.assertEqual(snapshot(self.project), before)
+
+    def test_pack_mutation_after_preflight_rolls_back_exactly(self) -> None:
+        before = snapshot(self.project)
+
+        def mutate_pack() -> None:
+            (self.pack / "bmad-agent-pm" / "SKILL.md").write_text("mutated after preflight\n")
+
+        with working_directory(self.project):
+            with self.assertRaisesRegex(ValueError, "digest mismatch"):
+                PROVISIONER.provision(after_preflight=mutate_pack)
+
+        self.assertEqual(snapshot(self.project), before)
+
+    def test_malformed_manifest_fails_before_creating_skills_or_temp_paths(self) -> None:
+        project = self.root / "malformed-project"
+        agents = project / ".agents"
+        agents.mkdir(parents=True)
+        manifest = agents / "skills.json"
+        manifest.write_bytes(b"{malformed\n")
+        manifest.chmod(0o600)
+        before = snapshot(project)
+
+        with working_directory(project):
+            with self.assertRaises(json.JSONDecodeError):
+                PROVISIONER.provision()
+
+        self.assertEqual(snapshot(project), before)
+        self.assertFalse((agents / "skills").exists())
+        self.assertFalse(any(path.name.startswith(".bmad-transaction-") for path in agents.iterdir()))
+
+    def test_applied_projection_mismatch_rolls_back_exactly(self) -> None:
+        before = snapshot(self.project)
+
+        def corrupt_projection(_manifest: Path, skills: Path) -> None:
+            link = skills / "bmad-agent-analyst"
+            link.unlink()
+            link.symlink_to("/tmp/wrong-after-apply", target_is_directory=True)
+
+        with working_directory(self.project):
+            with self.assertRaisesRegex(ValueError, "link differs from plan"):
+                PROVISIONER.provision(after_apply=corrupt_projection)
+
+        self.assertEqual(snapshot(self.project), before)
+
+    def test_success_is_complete_and_idempotent(self) -> None:
+        with working_directory(self.project):
+            self.assertGreater(PROVISIONER.provision(), 0)
+            after_first = snapshot(self.project)
+            self.assertEqual(PROVISIONER.provision(), 0)
+
+        self.assertEqual(snapshot(self.project), after_first)
+        skills = self.project / ".agents" / "skills"
+        self.assertTrue((skills / "bmad-private-custom").is_dir())
+        self.assertEqual(
+            (skills / "bmad-private-custom" / "SKILL.md").read_text(),
+            "private custom must survive\n",
+        )
+        self.assertFalse((skills / "bmad-stale").exists())
+        manifest = json.loads((self.project / ".agents" / "skills.json").read_text())
+        self.assertIn(
+            {
+                "name": "bmad-private-custom",
+                "source": (skills / "bmad-private-custom").as_uri(),
+            },
+            manifest["skills"],
+        )
+        self.assertNotIn("bmad-stale", [entry.get("name") for entry in manifest["skills"]])
+        self.assertTrue(
+            all(
+                (skills / path.name).is_symlink()
+                for path in PROVISIONER.validate_trusted_pack(self.pack)
+            )
+        )
+
+    def test_unowned_bmad_prefixed_custom_skill_is_preserved(self) -> None:
+        custom = self.project / ".agents" / "skills" / "bmad-private-custom"
+        before = snapshot(custom)
+
+        with working_directory(self.project):
+            self.assertGreater(PROVISIONER.provision(), 0)
+            after_first = snapshot(self.project)
+            self.assertEqual(PROVISIONER.provision(), 0)
+
+        self.assertEqual(snapshot(custom), before)
+        self.assertEqual(snapshot(self.project), after_first)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/templates/commonproject/tests/test_sync_skills_topology.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+import importlib.util
+import os
+import tempfile
+import unittest
+from pathlib import Path
+
+
+ROOT = Path(__file__).parents[1]
+SCRIPT = ROOT / "template" / ".mise" / "scripts" / "sync-skills.py"
+PROVISION_SCRIPT = ROOT / "template" / ".mise" / "scripts" / "provision-bmad-skills.py"
+SPEC = importlib.util.spec_from_file_location("sync_skills", SCRIPT)
+assert SPEC is not None and SPEC.loader is not None
+SYNC = importlib.util.module_from_spec(SPEC)
+SPEC.loader.exec_module(SYNC)
+
+
+class SyncSkillsTopologyTests(unittest.TestCase):
+    def setUp(self) -> None:
+        self.temporary = tempfile.TemporaryDirectory(prefix="commonproject-sync-topology-")
+        self.root = Path(self.temporary.name)
+        self.project = self.root / "project"
+        self.source = self.root / "source-skill"
+        self.project.mkdir()
+        self.source.mkdir()
+        (self.source / "SKILL.md").write_text("source\n")
+
+    def tearDown(self) -> None:
+        self.temporary.cleanup()
+
+    def test_shipped_skill_scripts_are_executable(self) -> None:
+        for script in (PROVISION_SCRIPT, SCRIPT):
+            self.assertNotEqual(
+                script.stat().st_mode & 0o111,
+                0,
+                f"fresh template script must be executable: {script}",
+            )
+
+    def test_canonical_claude_alias_is_accepted_without_mutating_managed_projection(self) -> None:
+        managed = self.project / ".agents" / "skills"
+        custom = managed / "custom-real-skill"
+        custom.mkdir(parents=True)
+        (custom / "SKILL.md").write_text("custom\n")
+        claude = self.project / ".claude"
+        claude.mkdir()
+        (claude / "skills").symlink_to("../.agents/skills", target_is_directory=True)
+
+        SYNC.fanout_to_cli(self.project, {"managed-example": self.source})
+
+        self.assertTrue((claude / "skills").is_symlink())
+        self.assertEqual(os.readlink(claude / "skills"), "../.agents/skills")
+        self.assertEqual((custom / "SKILL.md").read_text(), "custom\n")
+        self.assertFalse(
+            (managed / "managed-example").exists(),
+            "the canonical alias must not make sync-skills mutate the provisioner-owned projection",
+        )
+
+    def test_external_cli_symlink_fails_before_any_destination_mutation(self) -> None:
+        codex = self.project / ".codex"
+        codex.mkdir()
+        claude = self.project / ".claude"
+        claude.mkdir()
+        outside = self.root / "outside"
+        outside.mkdir()
+        (outside / "sentinel").write_text("do-not-touch\n")
+        (claude / "skills").symlink_to(outside, target_is_directory=True)
+
+        with self.assertRaisesRegex(ValueError, "Refusing symlinked CLI skills directory"):
+            SYNC.fanout_to_cli(self.project, {"managed-example": self.source})
+
+        self.assertFalse((codex / "skills").exists())
+        self.assertEqual(list(outside.iterdir()), [outside / "sentinel"])
+        self.assertEqual((outside / "sentinel").read_text(), "do-not-touch\n")
+
+    def test_broken_canonical_alias_fails_before_mutation(self) -> None:
+        codex = self.project / ".codex"
+        codex.mkdir()
+        claude = self.project / ".claude"
+        claude.mkdir()
+        (claude / "skills").symlink_to("../.agents/skills", target_is_directory=True)
+
+        with self.assertRaisesRegex(ValueError, "alias target is not a real directory"):
+            SYNC.fanout_to_cli(self.project, {"managed-example": self.source})
+
+        self.assertFalse((codex / "skills").exists())
+        self.assertTrue((claude / "skills").is_symlink())
+
+    def test_parent_swap_after_preflight_cannot_mutate_outside_project(self) -> None:
+        codex = self.project / ".codex"
+        codex.mkdir()
+        outside = self.root / "outside"
+        outside_skill = outside / "skills" / "managed-example"
+        outside_skill.mkdir(parents=True)
+        (outside / "sentinel").write_text("outside must survive\n")
+        (outside_skill / "user-data").write_text("do not delete\n")
+        active = SYNC.preflight_cli_dirs(self.project, ["managed-example"])
+        original_codex = self.project / ".codex-original"
+
+        def swap_parent() -> None:
+            codex.rename(original_codex)
+            codex.symlink_to(outside, target_is_directory=True)
+
+        with self.assertRaisesRegex(ValueError, "symlinked destination directory"):
+            SYNC.fanout_to_cli(
+                self.project,
+                {"managed-example": self.source},
+                active_cli_dirs=active,
+                before_mutation=swap_parent,
+            )
+
+        self.assertTrue(codex.is_symlink())
+        self.assertFalse((original_codex / "skills").exists())
+        self.assertEqual((outside / "sentinel").read_text(), "outside must survive\n")
+        self.assertEqual((outside_skill / "user-data").read_text(), "do not delete\n")
+        self.assertTrue(outside_skill.is_dir())
+
+
+if __name__ == "__main__":
+    unittest.main()

package/templates/hermes-agent/README.md

@@ -1,8 +1,8 @@
 # hermes-agent-template
 
 Copier template that provisions a single Hermes agent role into an existing
-repository, complete with its own per-agent runtime repo for git-tracked
-memory/state checkpointing.
+repository, complete with its own ignored per-agent runtime directory for
+memory and session state.
 
 ## How it relates to CommonProject
 
@@ -11,7 +11,7 @@ memory/state checkpointing.
 | What it scaffolds | A new top-level project | An agent role inside an existing project |
 | Copier target | `./my-new-project/` | `./agents/hermes/<role>/` |
 | Asks | project name + description | role + purpose + tone |
-| Post-gen artifacts | Plane project, bmad init, mise tasks | Plane project, Telegram bot wiring, agent-hm-* runtime repo, systemd units |
+| Post-gen artifacts | Plane project, bmad init, mise tasks | Plane project, Telegram bot wiring, optional Slack wiring, pure-local runtime, systemd units |
 
 CommonProject runs first to create the umbrella project. hermes-agent-template
 runs second (for each agent role you want) to drop agents into it.
@@ -22,9 +22,10 @@ The template provisions a single Hermes role per invocation. The `pm` role
 handles project management and triage, and also runs the continuous ticket
 sentinel out-of-band: a provider-agnostic board-reconciliation pass (Linear,
 Plane, or Trello) with an autonomous adversarial review (act, do not wait). The
-sentinel runs as the PM's **heartbeat** — a fused systemd timer tick that does
-the reconciliation pass and then a gated runtime checkpoint. (There is no
-separate `scrum-master` role; its duties folded into the PM heartbeat.)
+sentinel runs as the PM's **heartbeat** systemd timer. Under the current
+pure-local runtime contract, that tick performs board reconciliation only.
+(There is no separate `scrum-master` role; its duties folded into the PM
+heartbeat.)
 
 To work on or extend the heartbeat sentinel, start with the [sentinel handoff
 guide](docs/sentinel/README.md).
@@ -43,13 +44,15 @@ The template will:
 1. Seed `~/.config/hermes-agent-template/config.toml` from the shipped example (see [Configuration](#configuration))
 2. Ensure `~/.hermes/fleet.env` exists (single source of truth for shared Hermes binary/repo/registry)
 3. Create the hermes profile `<repo>-pm` via `hermes profile create --clone`
-4. Create a new private GitHub repo `<owner>/agent-hm-<repo>-pm` for the runtime
-5. Populate it with the runtime scaffold (config.yaml, SOUL.md, memories, consumer.py)
-6. Add it as a git submodule at `agents/hermes/pm/runtime/` (== HERMES_HOME)
-7. Prompt for a BotFather token, store it in `runtime/.env`
-8. Create a Plane project in your configured workspace
-9. Install systemd `--user` units: gateway, consumer, heartbeat timer (reconcile + checkpoint)
-10. Append the agent to `~/.hermes/agents-registry.yaml`
+4. Create ignored local state at `agents/hermes/pm/runtime/` (== HERMES_HOME)
+5. Populate missing files from the runtime scaffold (config.yaml, SOUL.md, memories)
+6. Refuse any stale project gitlink or `.gitmodules` mapping for that runtime
+7. Verify a profile-dedicated BotFather token and store it only in `runtime/.env`
+8. Defer Slack by default, or verify and store an explicitly supplied dedicated Slack app+bot pair in `runtime/.env`
+9. Create a Plane project in your configured workspace
+10. Mark Bloodbank ingress as fleet-scoped, with no per-profile consumer
+11. Install systemd `--user` units: profile gateway and board-reconciliation heartbeat timer
+12. Append the agent and its Bloodbank `target_agent_id` to `~/.hermes/agents-registry.yaml`
 
 ## Configuration
 
@@ -65,13 +68,16 @@ you to review it. Keys:
 | Section | Key | What it sets |
 | --- | --- | --- |
 | `fleet` | `hermes_bin`, `hermes_repo` | Shared Hermes executable + repo checkout |
+| `fleet` | `hermes_git_url`, `hermes_git_ref`, `hermes_git_sha` | Reviewed Hermes fork publication used by clean installs and fleet audit metadata |
 | `fleet` | `fleet_env`, `registry_file` | Fleet source-of-truth + registry locations |
 | `fleet` | `oauth_file`, `codex_home` | Shared Hermes OAuth store + Codex CLI/app-server auth home |
 | `fleet` | `runtime_scaffold_dir` | Fallback scaffold (if agent-local one is missing) |
 | `fleet` | `canonical_skills_dir`, `symlinked_runtime_skills` | Skills mirrored into each profile |
-| `github` | `runtime_repo_owner` | Owner of the `agent-hm-*` runtime repos |
 | `plane` | `base`, `workspace` | Plane URL + workspace slug |
-| `bloodbank` | `nats_host`, `nats_port`, `compose_dir` | NATS endpoint + compose dir hint |
+
+The example configuration retains an inert `[github].runtime_repo_owner` value
+only so older manifests can still be parsed. Current provisioning never reads
+it to create, attach, synchronize, restore, or retire runtime storage.
 
 Resolution precedence for every value: **explicit env var → `~/.hermes/fleet.env`
 → `config.toml` → built-in fallback**. So you can still override any single value
@@ -87,24 +93,51 @@ your-project/
 │   ├── SOUL.md                             ← personality (canonical)
 │   ├── hermes                              ← launcher
 │   ├── .scripts/                           ← provisioning scripts (idempotent re-run)
-│   └── runtime/                            ← git submodule → agent-hm-<repo>-pm
+│   └── runtime/                            ← ignored local HERMES_HOME
 │       (HERMES_HOME for this agent)
+│       └── .env                            ← profile-local channel credentials, mode 0600, gitignored
 └── ...
 
-github.com/delorenj/agent-hm-<repo>-pm/     ← new private repo, this agent's state
-├── config.yaml                             ← cloned from global ~/.hermes
-├── SOUL.md                                 ← evolves over time
-├── memories/{MEMORY,USER}.md
-├── sessions/sessions.db                    ← LFS-tracked
-├── decisions/                              ← markdown files, one per call
-├── bloodbank-consumer.py
-└── .gitattributes / .gitignore             ← LFS rules + secret guards
-
 ~/.hermes/agents-registry.yaml              ← fleet roster
 ~/.hermes/fleet.env                          ← shared Hermes binary/repo pointer
-~/.config/systemd/user/                     ← gateway, consumer, heartbeat timer
+~/.config/systemd/user/                     ← per-profile gateway + heartbeat timer
+```
+
+Bloodbank command ingress is not a per-profile daemon. One fleet-shared Hermes
+gateway reads the registry and routes canonical commands by
+`data.target_agent_id`; local runtime directories contain no NATS consumer or
+inbox bridge.
+Provisioning and `fleet-sync.sh --apply` also retire the old
+`hermes-<agent>-consumer.service`, even when an older `.done-70-systemd` marker
+exists. Retirement fails closed: a user-manager/query error, failed disable, or
+anything short of explicit `inactive` plus `disabled` leaves the unit file and
+registry metadata intact and reports unhealthy drift.
+
+Telegram and Slack ownership checks, identity claims, runtime credential
+writes, and registry upserts serialize on `${registry_file}.lock`. The lock is
+held by `flock`, so a crashed process cannot leave a stale logical lock; registry
+writes use an atomic replace, sync the containing directory where supported, and
+keep both registry and lock at mode `0600`. Profile credential replacements use
+the same file-plus-parent durability boundary and remain safe to retry when a
+durability sync reports an error.
+
+## Reviewed Hermes runtime publication
+
+Clean installs use only the reviewed fleet fork publication below. The local
+installer verifies the commit belongs to the named ref and refuses an existing
+checkout whose `origin` points elsewhere:
+
+```bash
+git clone --branch feature/PJAN-19-routing-publication --single-branch \
+  https://github.com/delorenj/hermes-agent.git ~/.hermes/hermes-agent
+git -C ~/.hermes/hermes-agent rev-parse HEAD
+# 113e1b182b6d72a7dd02a191f134a41668ceaf0e
 ```
 
+Do not install this fleet path from `NousResearch/hermes-agent` or mutate its
+`main` branch. Promotion happens on the fork publication ref and is pinned by
+full commit SHA in `config.example.toml` and each registry entry.
+
 ## Fleet single source-of-truth
 
 All generated launchers read `~/.hermes/fleet.env` for:
@@ -120,6 +153,12 @@ agent wrapper picks it up automatically. `HERMES_FLEET_OAUTH_FILE` is the
 shared Hermes provider OAuth store, including `openai-codex`; `HERMES_FLEET_CODEX_HOME`
 is the shared Codex CLI/app-server config/auth home.
 
+Telegram bot tokens and Slack bot/app tokens are deliberately excluded from
+this shared layer. They belong only in the enabled agent's `runtime/.env` and
+are checked for local profile ownership during provisioning; fleet config may
+carry the non-secret `TELEGRAM_ALLOWED_USERS` and `SLACK_ALLOWED_USERS`
+policies as a convenience.
+
 To retrofit existing wrappers and user systemd units:
 
 ```bash
@@ -146,6 +185,8 @@ SKIP_TELEGRAM=1 SKIP_SYSTEMD=1 ./.scripts/40-plane.sh
 
 (TODO: ship `retire.sh` in v1.1)
 
-Manual: stop systemd units, `hermes profile delete`, archive the Plane
-project, `/deletebot` in BotFather, archive the
-`agent-hm-*` runtime repo, remove the registry entry.
+Manual retirement is deliberately non-destructive: stop the systemd units,
+detach the profile symlink, archive the Plane project, retire messaging bots,
+and remove the registry entry while preserving the ignored runtime directory.
+The verified-backup and no-automated-purge retention policy is in
+[Operations](docs/operations.md#retire-an-agent-preserves-runtime-by-default).

package/templates/hermes-agent/copier.yml

@@ -10,14 +10,16 @@
 #
 # What it does:
 #   1. Renders agents/hermes/<role>/{role.yaml, SOUL.md, hermes, .scripts/}
-#   2. Creates a per-agent runtime repo gh:delorenj/agent-hm-<repo>-<role>
-#   3. Submodules it at agents/hermes/<role>/runtime/  (this is HERMES_HOME)
+#   2. Creates ignored local state at agents/hermes/<role>/runtime/
+#      (this is HERMES_HOME; no project gitlink or runtime remote)
 #   4. Creates a Plane project in 33god workspace
 #   6. Prompts for a BotFather Telegram token, stores in runtime/.env
-#   7. Installs a Bloodbank consumer + heartbeat timer (reconcile + checkpoint)
-#   8. Appends to ~/.hermes/agents-registry.yaml
+#   7. Optionally wires a dedicated Slack app+bot pair into runtime/.env
+#   8. Records fleet-shared Bloodbank routing identity (no profile consumer)
+#   9. Installs a profile gateway + heartbeat timer (reconcile + checkpoint)
+#  10. Appends to ~/.hermes/agents-registry.yaml
 #
-# Environment-specific defaults (Hermes binary path, runtime repo owner, Plane
+# Environment-specific defaults (Hermes binary path, legacy archive owner, Plane
 # workspace/URL, NATS endpoint, skills dir, …) are NOT hardcoded — they live in
 # ~/.config/hermes-agent-template/config.toml, seeded from config.example.toml on
 # first run. Edit that file to retarget the template for a different machine/user.
@@ -113,7 +115,7 @@ runtime_repo:
 
 runtime_repo_owner:
   type: str
-  # Empty by default — resolved at provision time from
+# Legacy archive identity only. Empty by default — resolved at provision time from
   # ~/.config/hermes-agent-template/config.toml [github].runtime_repo_owner.
   # Pass --data runtime_repo_owner=<owner> to override per-run.
   default: ""
@@ -138,6 +140,7 @@ _tasks:
   - "./.scripts/10-hermes-profile.sh"
   - "./.scripts/20-runtime-repo.sh"
   - "./.scripts/30-telegram.sh"
+  - "./.scripts/31-slack.sh"
   - "./.scripts/42-ticket-provider.sh"
   - "./.scripts/60-bloodbank.sh"
   - "./.scripts/70-systemd.sh"