wicked-garden 12.27.0

package/hooks/scripts/task_completed.py

@@ -0,0 +1,322 @@
+#!/usr/bin/env python3
+"""
+TaskCompleted hook — wicked-garden memory capture on task completion.
+
+Fires when Claude Code marks a task as completed (TaskCompleted event).
+This hook does NOT use matchers — it fires for all task completions.
+
+Responsibilities:
+1. Increment memory_compliance_tasks_completed in session state.
+2. For any deliverable-producing task, emit a systemMessage directive
+   asking Claude to evaluate the completed task for storable learnings.
+   Uses stronger language when memory_compliance_required (crew project).
+
+Always returns {"ok": true} — task completion is never blocked.
+Wraps all logic in try/except and fails open.
+
+Input schema (from Claude Code):
+    {"task_id": "...", "subject": "...", "status": "completed"}
+"""
+
+import json
+import os
+import sys
+import time
+from pathlib import Path
+
+# Add shared scripts directory to path
+_PLUGIN_ROOT = Path(os.environ.get("CLAUDE_PLUGIN_ROOT", Path(__file__).resolve().parents[2]))
+sys.path.insert(0, str(_PLUGIN_ROOT / "scripts"))
+
+
+# ---------------------------------------------------------------------------
+# Ops logger wrapper — fail-silent, never crashes the hook
+# ---------------------------------------------------------------------------
+
+# R4-suppressed by design: _logger is optional; the hook must never crash if
+# ops logging is unavailable. We do not surface the exception because this
+# runs on every task completion — a stderr dump would spam normal workflows.
+def _log(domain, level, event, ok=True, ms=None, detail=None):
+    """Ops logger — fail-silent, never crashes the hook."""
+    try:
+        from _logger import log
+        log(domain, level, event, ok=ok, ms=ms, detail=detail)
+    except Exception:  # noqa: BLE001 — intentional swallow, see comment above
+        return
+
+# Escalation threshold — after this many consecutive completed tasks without
+# a wicked-brain:memory call, the memory directive switches to [ESCALATION]
+# language. Named per R3 (no magic numbers); historical value = 3.
+_ESCALATION_THRESHOLD = 3
+
+# Keywords that suggest a deliverable-producing task
+_DELIVERABLE_PATTERNS = (
+    "phase:",
+    "implement",
+    "write",
+    "design",
+    "build",
+    "create",
+    "develop",
+    "refactor",
+    "migrate",
+    "fix",
+    "resolve",
+    "deploy",
+    "integrate",
+    "add",
+    "update",
+    "test",
+    "review",
+    "document",
+    "configure",
+    "setup",
+    "scaffold",
+    "generate",
+    "analyze",
+)
+
+
+def _is_deliverable_task(subject: str) -> bool:
+    """Return True if the task subject suggests it produced a deliverable."""
+    subject_lower = subject.lower()
+    return any(kw in subject_lower for kw in _DELIVERABLE_PATTERNS)
+
+
+def _infer_mem_type(subject: str) -> str:
+    """Infer the most appropriate wicked-brain:memory type from task subject."""
+    s = subject.lower()
+    if any(kw in s for kw in ("fix", "resolve", "bug", "defect")):
+        return "decision"
+    if any(kw in s for kw in ("phase:", "design", "architect", "strategy")):
+        return "episodic"
+    return "procedural"
+
+
+# Issue #572: event_type + verdict constants used by the re-eval debounce rule.
+# Re-eval is meaningful ONLY on phase boundaries or rejected gates — every other
+# completion is bus noise that wakes the facilitator for nothing.
+EVENT_TYPE_PHASE_TRANSITION = "phase-transition"
+EVENT_TYPE_GATE_FINDING = "gate-finding"
+VERDICT_REJECT = "REJECT"
+
+
+def _read_task_metadata(session_id: str, task_id: str) -> "dict | None":
+    """Read ``metadata`` dict from the native task JSON file (or daemon projection).
+
+    Fail-open: returns None on any error.  Routing is delegated to
+    scripts/crew/_task_reader.py per #596 v8-PR-2.
+
+    WG_DAEMON_ENABLED=false (default): direct file read, bit-identical to pre-PR-2.
+    WG_DAEMON_ENABLED=true:            daemon HTTP with fallback.
+    WG_DAEMON_ENABLED=always:          daemon HTTP only.
+    """
+    if not session_id or not task_id:
+        return None
+    try:
+        from crew._task_reader import get_task_metadata  # type: ignore[import]
+        return get_task_metadata(session_id, task_id)
+    except Exception:
+        return None
+
+
+def _should_trigger_reeval(metadata: "dict | None") -> "tuple[bool, str]":
+    """Return (should_trigger, reason) for the facilitator re-eval signal.
+
+    Issue #572: only phase boundaries and gate rejections should wake the
+    facilitator. All other completions (shell gate ACKs, plain tasks,
+    coding-tasks, etc.) are noise that accumulated 41k+ events.
+
+    Rule:
+        event_type == phase-transition                         -> trigger
+        event_type == gate-finding AND verdict == REJECT       -> trigger
+        anything else (including APPROVE/CONDITIONAL, plain task) -> skip
+
+    Fail-open: missing metadata returns (False, "no_metadata"). The flag is
+    NEVER set when the task file can't be read — the old "chain_id truthy =
+    trigger" behaviour is the exact bug this closes.
+    """
+    if not metadata:
+        return (False, "no_metadata")
+    event_type = metadata.get("event_type")
+    if event_type == EVENT_TYPE_PHASE_TRANSITION:
+        return (True, "phase_transition")
+    if event_type == EVENT_TYPE_GATE_FINDING:
+        verdict = metadata.get("verdict")
+        if verdict == VERDICT_REJECT:
+            return (True, "gate_reject")
+        return (False, f"gate_verdict_{verdict or 'missing'}")
+    return (False, f"event_type_{event_type or 'missing'}")
+
+
+def _update_session_state(
+    *,
+    chain_id: str | None,
+    event_type: str | None,
+    should_reeval: bool,
+    reeval_reason: str,
+) -> tuple[bool, int]:
+    """Mutate SessionState for the completed task.
+
+    Increments memory-compliance counters, sets the debounced re-eval flag
+    (Issue #572), and sets the phase-start-gate flag on phase-transition
+    events. Returns ``(compliance_required, escalations)`` for the caller's
+    memory-directive branch.
+
+    Fail-open: any exception returns ``(False, 0)`` and logs to stderr so
+    the hook never blocks task completion.
+    """
+    try:
+        from _session import SessionState
+        state = SessionState.load()
+        state.memory_compliance_tasks_completed = (
+            (state.memory_compliance_tasks_completed or 0) + 1
+        )
+        compliance_required = bool(state.memory_compliance_required)
+        state.memory_compliance_escalations = (
+            (state.memory_compliance_escalations or 0) + 1
+        )
+        escalations = state.memory_compliance_escalations
+
+        # v11: facilitator re-evaluation signal removed. The v6 re-eval
+        # mechanism was tied to the universal pipeline (propose-process
+        # facilitator rubric). v11 archetypes own their own re-evaluation
+        # cadence via the playbook's checkpoint phases. Telemetry-only
+        # logging preserved so we can detect if the producer fires
+        # against the now-deleted consumers.
+        _log("task", "debug", "reeval.skipped.v11", detail={
+            "reason": reeval_reason,
+            "event_type": event_type,
+            "chain_id": chain_id,
+            "would_have_reeval": bool(should_reeval and chain_id),
+        })
+
+        state.save()
+        return compliance_required, escalations
+    except Exception as exc:
+        print(
+            f"[wicked-garden] task_completed session state error: {exc}",
+            file=sys.stderr,
+        )
+        return False, 0
+
+
+def main():
+    _t0 = time.monotonic()
+
+    # Read task data from stdin
+    try:
+        raw = sys.stdin.read()
+        input_data = json.loads(raw) if raw.strip() else {}
+    except Exception:
+        input_data = {}
+
+    try:
+        subject = input_data.get("subject", "")
+        task_id = input_data.get("task_id", "")
+        session_id = input_data.get("session_id", os.environ.get("CLAUDE_SESSION_ID", ""))
+
+        _log("task", "debug", "hook.start")
+
+        # Issue #572: load metadata ONCE and derive all downstream signals from
+        # it. The old code read the task file twice (chain_id, then event_type
+        # in a nested try block) and set facilitator_reeval_due on any truthy
+        # chain_id — including gate-finding shell completions the orchestrator
+        # just acked. Debounce is now: phase-transition OR (gate-finding AND
+        # verdict=REJECT).
+        metadata = _read_task_metadata(session_id, task_id) or {}
+        chain_id_val = metadata.get("chain_id") if isinstance(metadata, dict) else None
+        chain_id = chain_id_val if isinstance(chain_id_val, str) and chain_id_val.strip() else None
+        event_type = metadata.get("event_type") if isinstance(metadata, dict) else None
+
+        should_reeval, reeval_reason = _should_trigger_reeval(metadata)
+        compliance_required, escalations = _update_session_state(
+            chain_id=chain_id,
+            event_type=event_type,
+            should_reeval=should_reeval,
+            reeval_reason=reeval_reason,
+        )
+
+        # Emit a memory directive for any deliverable-producing task.
+        # Crew projects get stronger "REQUIRED" language; normal sessions
+        # get a lighter nudge so memories still get captured.
+        system_message = ""
+        if subject and _is_deliverable_task(subject):
+            mem_type = _infer_mem_type(subject)
+            task_label = f'"{subject}"' if subject else f"task {task_id}"
+            if compliance_required:
+                escalation_prefix = (
+                    "[ESCALATION] " if escalations >= _ESCALATION_THRESHOLD else ""
+                )
+                system_message = (
+                    f"{escalation_prefix}[Memory] Task {task_label} completed. "
+                    f"REQUIRED: Call wicked-brain:memory with type={mem_type} "
+                    "to capture any decision, gotcha, or pattern from this work. "
+                    "If genuinely nothing is worth storing, respond with 'No memory stored: <reason>'."
+                )
+            else:
+                system_message = (
+                    f"[Memory] Task {task_label} completed. "
+                    "If this produced a decision, gotcha, or reusable pattern, "
+                    f"store it with wicked-brain:memory (type={mem_type})."
+                )
+
+        # Evidence nudge for crew tasks (Issue #253).
+        # Remind agents to include structured evidence in TaskUpdate descriptions.
+        if compliance_required and subject and _is_deliverable_task(subject):
+            evidence_nudge = (
+                " [Evidence] Ensure your TaskUpdate description includes structured evidence: "
+                "test results (PASS/FAIL), files modified/created, and verification steps. "
+                "Phase approval validates evidence at complexity >= 3."
+            )
+            system_message = (system_message or "") + evidence_nudge
+
+        # Claim sentinel — a completed deliverable task is the in-session "done"
+        # moment. Two invariants, both answer-tier, both observed-state (never a
+        # guess): (1) does a re-derived verdict cover HEAD? (2) is the recorded
+        # testing evidence fresher than the modified source? Fail-open.
+        if subject and _is_deliverable_task(subject):
+            try:
+                sentinel_dir = str(_PLUGIN_ROOT / "scripts" / "sentinel")
+                if sentinel_dir not in sys.path:
+                    sys.path.insert(0, sentinel_dir)
+                from invariants import (  # type: ignore
+                    check_evidence_freshness, log_sentinel_event, render,
+                    repo_toplevel, verdict_for,
+                )
+                repo = repo_toplevel()
+                if repo is not None:
+                    if verdict_for(repo) is None:
+                        violation = {
+                            "tier": "answer",
+                            "invariant": "done-claim-verdict",
+                            "evidence": (f'task "{subject}" completed with no re-derived '
+                                         "verdict covering HEAD"),
+                            "action": ("Run `/wicked-garden:prove` to re-derive the claim, "
+                                       "or state the override reason — this completion is "
+                                       "logged either way."),
+                        }
+                        log_sentinel_event(repo, "unverified_task_done",
+                                           {"task": subject,
+                                            "invariant": "done-claim-verdict"})
+                        system_message = ((system_message + "\n") if system_message else "") + render(violation)
+                    stale = check_evidence_freshness(repo)
+                    if stale:
+                        system_message = ((system_message + "\n") if system_message else "") + render(stale)
+            except Exception:  # noqa: BLE001 — the sentinel never breaks the hook
+                pass
+
+        output: dict = {"ok": True}
+        if system_message:
+            output["systemMessage"] = system_message
+
+        _log("task", "debug", "hook.end", ms=int((time.monotonic() - _t0) * 1000))
+        print(json.dumps(output))
+
+    except Exception as e:
+        print(f"[wicked-garden] task_completed hook error: {e}", file=sys.stderr)
+        print(json.dumps({"ok": True}))
+
+
+if __name__ == "__main__":
+    main()

package/hooks/scripts/worktree_guard.py

@@ -0,0 +1,148 @@
+#!/usr/bin/env python3
+"""worktree_guard.py — prevent the agent-worktree cwd leak (issue #878).
+
+When a subagent runs with ``isolation: worktree``, the Bash tool's persistent
+cwd can drift back to the MAIN repo checkout between calls. Commits then land
+on the agent's branch but in the main worktree — silently defeating isolation.
+The only post-hoc tell is an unexpected entry in ``git worktree list``.
+
+This guard is invoked from ``pre_tool.py``'s Bash handler. Given the command
+and the PreToolUse payload ``cwd``, it returns one of:
+
+  * ``None``                                   — not a worktree agent / no-op
+  * ``{"action": "rewrite", "command": ...}``  — anchor execution in the worktree
+  * ``{"action": "deny",    "reason":  ...}``  — command explicitly targets main repo
+
+The rewrite prepends ``cd <worktree-root> &&`` so persistent-cwd state cannot
+drag a later call into the wrong directory. Claude Code honors ``updatedInput``
+for PreToolUse Bash hooks, so the rewrite takes effect transparently.
+
+Contract: **pure and fail-open** — stdlib only, no raises escape ``evaluate``;
+any internal error returns ``None`` so the guard can never break an agent run.
+Main-repo path is derived generally via ``git rev-parse --git-common-dir`` —
+nothing about any specific repo is hardcoded.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import shlex
+import subprocess
+
+# Signature of an isolated agent worktree: <main>/.claude/worktrees/agent-<id>.
+# Captures everything up to and including the agent-<id> segment, so a cwd that
+# is a deeper subdirectory of the worktree still resolves to the worktree root.
+_WORKTREE_SIG = re.compile(r"^(.*/\.claude/worktrees/agent-[^/]+)")
+
+# `-C <path>` arguments (git, make, etc.) and a leading `cd <path>`.
+_DASH_C = re.compile(r"(?:^|\s)-C\s+(\S+)")
+_LEADING_CD = re.compile(r"^\s*cd\s+(\S+)")
+
+
+def worktree_root(cwd: "str | None") -> "str | None":
+    """Return the agent-worktree root if ``cwd`` is inside one, else ``None``."""
+    if not cwd:
+        return None
+    m = _WORKTREE_SIG.match(cwd)
+    return m.group(1) if m else None
+
+
+def _main_repo_root(cwd: str) -> "str | None":
+    """Best-effort main-repo root via ``git rev-parse --git-common-dir``.
+
+    From inside a linked worktree the common dir is the MAIN repo's ``.git``;
+    its parent is the main repo root. Returns ``None`` on any failure — callers
+    must treat an unknown main root as "cannot prove a main-repo reference".
+    """
+    try:
+        out = subprocess.run(
+            ["git", "rev-parse", "--git-common-dir"],
+            cwd=cwd,
+            capture_output=True,
+            text=True,
+            timeout=2,
+        )
+        if out.returncode != 0:
+            return None
+        common = out.stdout.strip()
+        if not common:
+            return None
+        if not os.path.isabs(common):
+            common = os.path.abspath(os.path.join(cwd, common))
+        # common dir is typically ``<main>/.git`` — main root is its parent.
+        if os.path.basename(common) == ".git":
+            common = os.path.dirname(common)
+        return os.path.normpath(common)
+    except Exception:
+        return None
+
+
+def _norm(path: str, base: str) -> str:
+    """Normalize ``path`` to an absolute path, resolving relatives against ``base``."""
+    path = path.strip().strip('"').strip("'")
+    if not os.path.isabs(path):
+        path = os.path.join(base, path)
+    return os.path.normpath(path)
+
+
+def _references_main_repo(command: str, main_root: "str | None", wt_root: str) -> bool:
+    """True if ``command`` explicitly targets the main repo root (not the worktree).
+
+    Compares normalized *full paths* for equality rather than substring matching,
+    because the main repo root is a path *prefix* of the worktree root — a naive
+    substring check would flag every command.
+    """
+    if not main_root or main_root == wt_root:
+        return False
+    candidates = list(_DASH_C.findall(command))
+    lead = _LEADING_CD.match(command)
+    if lead:
+        candidates.append(lead.group(1))
+    main_norm = os.path.normpath(main_root)
+    for c in candidates:
+        if _norm(c, wt_root) == main_norm:
+            return True
+    return False
+
+
+def _anchor_prefix(wt_root: str) -> str:
+    """The ``cd <worktree> && `` prefix, with the path safely shell-quoted."""
+    return f"cd {shlex.quote(wt_root)} && "
+
+
+def evaluate(command: "str | None", cwd: "str | None") -> "dict | None":
+    """Decide what to do with a Bash ``command`` given the PreToolUse ``cwd``.
+
+    Returns a decision dict (``rewrite`` / ``deny``) or ``None`` for a no-op.
+    Never raises — fail-open is the contract.
+    """
+    try:
+        if not command or not command.strip():
+            return None
+
+        wt_root = worktree_root(cwd)
+        if not wt_root or not cwd:
+            return None  # normal session — the guard does not engage
+
+        main_root = _main_repo_root(cwd)
+        if _references_main_repo(command, main_root, wt_root):
+            return {
+                "action": "deny",
+                "reason": (
+                    "[wicked-garden] worktree guard: this command targets the "
+                    f"main repo ({main_root}) from inside an isolated worktree "
+                    f"({wt_root}). Running it there would defeat worktree "
+                    "isolation — changes/commits would land in the wrong "
+                    "checkout. Drop the main-repo path / `-C` reference and run "
+                    "against the worktree instead."
+                ),
+            }
+
+        prefix = _anchor_prefix(wt_root)
+        if command.lstrip().startswith(prefix):
+            return None  # already anchored — idempotent, do not double-prefix
+
+        return {"action": "rewrite", "command": prefix + command}
+    except Exception:
+        return None  # fail open — never break an agent run

package/hooks/subscriptions/on_gate_decided.json

@@ -0,0 +1,9 @@
+{
+  "subscription_id": "wg-on-gate-decided-v1",
+  "filter": "wicked.gate.decided",
+  "handler": "hooks/scripts/subscribers/on_gate_decided.py",
+  "debounce": {
+    "type": "phase-boundary"
+  },
+  "enabled": true
+}

package/install.mjs

@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+/**
+ * wicked-garden installer
+ * Copies plugin files to ~/.claude/plugins/wicked-garden/ and optionally syncs Python deps.
+ *
+ * Usage:
+ *   npx wicked-garden install    Install or update the plugin
+ *   npx wicked-garden update     Same as install
+ *   npx wicked-garden status     Show current install state
+ *   npx wicked-garden --version  Print version
+ */
+import { cpSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
+import { execSync } from "node:child_process";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(join(__dirname, "package.json"), "utf8"));
+
+const PLUGIN_DIRS  = [".claude-plugin", "agents", "commands", "hooks", "scripts", "skills"];
+const PLUGIN_FILES = ["ETHOS.md", "CHANGELOG.md", "README.md", "WICKED_GARDEN_BUS_EVENTS.md", "pyproject.toml"];
+const SKIP         = [/__pycache__/, /\.pyc$/, /\.pyo$/, /\.DS_Store$/];
+// Dev-only subdirs within scripts/ — not needed at runtime
+const SCRIPTS_DEV  = ["ci", "wg"];
+
+function skip(src) {
+  if (SKIP.some(p => p.test(src))) return true;
+  // Strip dev-only scripts/ subdirs — they exist in the npm package but serve no runtime purpose
+  const m = src.match(/[/\\]scripts[/\\]([^/\\]+)/);
+  if (m && SCRIPTS_DEV.includes(m[1])) return true;
+  return false;
+}
+
+function findBin(name) {
+  try {
+    const out = execSync(
+      process.platform === "win32" ? `where ${name}` : `command -v ${name}`,
+      { stdio: ["ignore", "pipe", "ignore"], timeout: 2000, encoding: "utf8" }
+    ).trim().split("\n")[0];
+    return out || undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+async function cmdInstall() {
+  const dest      = join(homedir(), ".claude", "plugins", "wicked-garden");
+  const isUpdate  = existsSync(dest);
+
+  console.log(isUpdate
+    ? `Updating wicked-garden v${pkg.version} at ${dest}...`
+    : `Installing wicked-garden v${pkg.version} to ${dest}...`
+  );
+
+  mkdirSync(dest, { recursive: true });
+
+  for (const dir of PLUGIN_DIRS) {
+    const src = join(__dirname, dir);
+    if (!existsSync(src)) continue;
+    process.stdout.write(`  ${dir}/... `);
+    cpSync(src, join(dest, dir), { recursive: true, force: true, filter: (s) => !skip(s) });
+    console.log("done");
+  }
+
+  for (const file of PLUGIN_FILES) {
+    const src = join(__dirname, file);
+    if (existsSync(src)) cpSync(src, join(dest, file), { force: true });
+  }
+
+  // Sync Python deps via uv if available (setup will retry if this is skipped)
+  const uv = findBin("uv");
+  if (uv) {
+    process.stdout.write("  Python deps (uv sync)... ");
+    try {
+      execSync(`"${uv}" sync --quiet`, { cwd: dest, stdio: "pipe" });
+      console.log("done");
+    } catch {
+      console.log("skipped — /wicked-garden:setup will retry");
+    }
+  }
+
+  console.log(`\nwicked-garden v${pkg.version} ${isUpdate ? "updated" : "installed"}.`);
+  console.log("Next: run /wicked-garden:setup in Claude Code to complete configuration.");
+}
+
+function cmdStatus() {
+  const dest = join(homedir(), ".claude", "plugins", "wicked-garden");
+  if (!existsSync(dest)) {
+    console.log("wicked-garden: not installed");
+    console.log(`  Run: npx wicked-garden@${pkg.version} install`);
+    return;
+  }
+  try {
+    const installed = JSON.parse(readFileSync(join(dest, ".claude-plugin", "plugin.json"), "utf8"));
+    const upToDate  = installed.version === pkg.version;
+    console.log(`wicked-garden: installed`);
+    console.log(`  path:    ${dest}`);
+    console.log(`  version: ${installed.version}${upToDate ? "" : ` (package: ${pkg.version} — run install to update)`}`);
+  } catch {
+    console.log(`wicked-garden: installed at ${dest} (plugin.json unreadable)`);
+  }
+}
+
+const cmd = process.argv[2];
+switch (cmd) {
+  case "install":
+  case "update":
+  case undefined:
+    cmdInstall().catch(err => { console.error("Error:", err.message); process.exit(1); });
+    break;
+  case "status":
+    cmdStatus();
+    break;
+  case "--version":
+  case "-v":
+    console.log(pkg.version);
+    break;
+  default:
+    console.log([
+      `wicked-garden v${pkg.version}`,
+      "",
+      "Usage:",
+      "  npx wicked-garden install    Install or update the plugin",
+      "  npx wicked-garden status     Show current install state",
+      "  npx wicked-garden --version  Show version",
+    ].join("\n"));
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "wicked-garden",
+  "version": "12.27.0",
+  "type": "module",
+  "description": "Curated toolkit for what AI coding agents can't do alone: evidence-gated work, codegraph relationships, deterministic multi-file refactor, multi-model second opinions, and cross-session memory. Installs as a Claude Code plugin.",
+  "keywords": [
+    "ai",
+    "coding-agent",
+    "claude-code",
+    "evidence-gate",
+    "code-graph",
+    "code-intelligence",
+    "refactoring",
+    "testing",
+    "memory",
+    "multi-model",
+    "agentic",
+    "wicked-testing",
+    "wicked-bus"
+  ],
+  "author": {
+    "name": "Mike Parcewski"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mikeparcewski/wicked-garden.git"
+  },
+  "homepage": "https://github.com/mikeparcewski/wicked-garden",
+  "bugs": "https://github.com/mikeparcewski/wicked-garden/issues",
+  "bin": {
+    "wicked-garden": "install.mjs"
+  },
+  "main": "install.mjs",
+  "scripts": {
+    "prepublishOnly": "node install.mjs --version"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  }
+}