kind is a deployment property, not a program property

A program has no single kind — it HAS deployments, each with its own kind (a
program can be a tool AND a job, e.g. protonmail). Remove program-level kind:

- core: drop ProgramSpec.kind; CastleConfig.kind_of → deployments_of(name) →
  [(deployment-name, kind)]; tools property derives from a tool deployment.
- api: ProgramSummary drops kind/services/jobs → deployments: [{name, kind}];
  /programs?kind= filters by deployment-kind membership; a program's legacy
  DeploymentSummary carries kind=None.
- cli: list/info show a program's set of deployment kinds; --kind filters by
  membership.

Also: Services page now covers statics — /services returns kind in
{service, static} (both are exposed, URL-reachable 'services', caddy vs systemd),
and ServiceSummary gains kind + manager to distinguish them.

Suites: core 124, cli 25, castle-api 58.

cli/src/castle_cli/commands/create.py

@@ -144,10 +144,6 @@ def run_create(args: argparse.Namespace) -> int:
             ),
         )
 
-    # Populate the derived kind on the in-memory program so readers see the live
-    # value immediately (it's excluded from disk — kind_of recomputes on load).
-    config.programs[name].kind = config.kind_of(name)
-
     save_config(config)
 
     label = f"{stack} program" if stack else "bare program"

cli/src/castle_cli/commands/info.py

@@ -53,16 +53,18 @@ def run_info(args: argparse.Namespace) -> int:
     print(f"\n{BOLD}{name}{RESET}")
     print(f"{'─' * 40}")
 
-    # Determine kind (derived)
-    kind = None
-    if program and program.kind:
-        kind = program.kind
+    # Determine kind(s) — for a program, the kinds of its deployments; for a
+    # single deployment, its own kind.
+    kinds: list[str] = []
+    if program:
+        kinds = sorted({k for _, k in config.deployments_of(name)})
     elif service:
-        kind = "service"
+        kinds = ["service"]
     elif job:
-        kind = "job"
-    if kind:
-        print(f"  {BOLD}kind{RESET}:        {kind}")
+        kinds = ["job"]
+    if kinds:
+        label = "kind" if len(kinds) == 1 else "kinds"
+        print(f"  {BOLD}{label}{RESET}:        {', '.join(kinds)}")
 
     # Show stack
     stack = None
@@ -182,8 +184,8 @@ def _info_json(
         data["service"] = service.model_dump(exclude_none=True, exclude={"id"})
     if job:
         data["job"] = job.model_dump(exclude_none=True, exclude={"id"})
-    if program and program.kind:
-        data["kind"] = program.kind
+    if program:
+        data["kinds"] = sorted({k for _, k in config.deployments_of(name)})
     elif service:
         data["kind"] = "service"
     elif job:

cli/src/castle_cli/commands/list_cmd.py

@@ -84,12 +84,17 @@ def run_list(args: argparse.Namespace) -> int:
 
     any_output = False
 
-    # Programs (the catalog) — filtered by real behavior + stack
+    # A program's kinds are the kinds of its deployments (a program has no kind
+    # of its own). Sorted, de-duplicated.
+    def prog_kinds(name: str) -> list[str]:
+        return sorted({kind for _, kind in config.deployments_of(name)})
+
+    # Programs (the catalog) — filtered by a deployment kind + stack.
     progs = (
         {
             name: comp
             for name, comp in config.programs.items()
-            if (not filter_kind or comp.kind == filter_kind)
+            if (not filter_kind or filter_kind in prog_kinds(name))
             and (not filter_stack or comp.stack == filter_stack)
         }
         if resource in (None, "program")
@@ -100,12 +105,13 @@ def run_list(args: argparse.Namespace) -> int:
         print(f"\n{BOLD}{CYAN}Programs{RESET}")
         print(f"{CYAN}{'─' * 40}{RESET}")
         for name, comp in progs.items():
-            kind = comp.kind or "program"
-            bcolor = KIND_COLORS.get(kind, "")
-            behavior_str = f"  {bcolor}{kind}{RESET}"
+            kinds = prog_kinds(name)
+            kinds_str = "".join(
+                f"  {KIND_COLORS.get(k, '')}{k}{RESET}" for k in kinds
+            )
             stack_str = f"  {DIM}{comp.stack}{RESET}" if comp.stack else ""
             desc = f"  {DIM}{comp.description}{RESET}" if comp.description else ""
-            print(f"  {dot(name)} {BOLD}{name}{RESET}{behavior_str}{stack_str}{desc}")
+            print(f"  {dot(name)} {BOLD}{name}{RESET}{kinds_str}{stack_str}{desc}")
 
     # Services + Jobs (deployment views) — independent of behavior, so only shown
     # when no behavior filter is applied. Each gated by its own resource scope.
@@ -168,15 +174,16 @@ def _list_json(
 
     output = []
 
-    # Programs (catalog) — filtered by derived kind + stack
+    # Programs (catalog) — a program's kinds are its deployments' kinds.
     for name, comp in config.programs.items():
-        if filter_kind and comp.kind != filter_kind:
+        kinds = sorted({kind for _, kind in config.deployments_of(name)})
+        if filter_kind and filter_kind not in kinds:
             continue
         if filter_stack and comp.stack != filter_stack:
             continue
         entry: dict = {
             "name": name,
-            "kind": comp.kind,
+            "kinds": kinds,
             "active": is_active(name, config),
         }
         if comp.stack:

cli/src/castle_cli/commands/service.py

@@ -183,7 +183,9 @@ def run_status(args: argparse.Namespace) -> int:
             on = is_active(name, config)
             color = "\033[92m" if on else "\033[90m"
             label = "active" if on else "inactive"
-            print(f"  {color}{label:10s}\033[0m  {name}  ({comp.kind or 'program'})")
+            kinds = sorted({k for _, k in config.deployments_of(name)})
+            tag = ", ".join(kinds) if kinds else "program"
+            print(f"  {color}{label:10s}\033[0m  {name}  ({tag})")
         print()
     return 0