werkmeister 0.0.0 → 0.14.0

package/CONVENTIONS.md

@@ -0,0 +1,55 @@
+# Code conventions — `src/`
+
+Conventions this CLI holds itself to. They exist because the runtime data in
+`infra/` and `docs/standards/` is consumed as-is and much of the output is
+contract-shaped: generated files, exit codes, and printed text are depended on
+by other tooling, so they are not free to drift.
+
+## Layout
+
+| Path | Holds |
+|---|---|
+| `src/main.ts` | the commander program and command registry |
+| `src/commands/<name>.ts` | one module per CLI command |
+| `src/lib/<name>.ts` | shared library modules |
+
+Runtime data dirs live alongside the source: `infra/`, `docs/standards/`, `bin/`.
+Path resolution: repo root = `SANDBOX_ROOT` env, else two levels up from
+`dist/lib/` (`src/lib/config.ts` owns `getSandboxRoot()` / `getInfraRoot()`).
+
+## Language
+
+- **ESM + NodeNext**: every relative import ends in `.js`
+  (`import { x } from "./config.js"`).
+- Keep a module docstring at the top of each file explaining what it owns.
+- Functions/vars are `camelCase`; classes/types `PascalCase`; module-level
+  private constants `_UPPER_SNAKE`.
+- **The CLI surface is frozen**: flag names, defaults, help text, printed
+  output, exit codes, and JSON shapes are contracts. Changing one is a
+  deliberate, breaking change — not a cleanup.
+- YAML via the `yaml` package (`parse`, `stringify`).
+- Templates in `infra/templates/` are rendered with `nunjucks`. They are shared
+  verbatim with other consumers, so the environment options in `generate.ts`
+  (autoescape, trim/lstrip) are load-bearing — see the notes there before
+  touching them.
+- Subprocesses go through `src/lib/proc.ts` (spawnSync-based, synchronous):
+  - `run(cmd: string[], opts)` → `{ status, stdout, stderr }`; `check: true` throws `ProcError`.
+  - `capture(cmd)` → trimmed stdout, throws on failure.
+  - Streaming/inherit-stdio cases: pass `stdio: "inherit"`.
+  - `timeout` is in **seconds**, not milliseconds.
+- Filesystem work uses the sync `node:fs` API (`readFileSync` etc.) plus `node:path`.
+- ANSI colors come from `src/lib/colors.ts` — the single definition site.
+- `console.error` for stderr, `console.log` for stdout.
+- `process.exit(n)` for exit codes. Thrown errors reach `main`, which prints
+  `Error: <msg>` in red and exits 1; `SANDBOX_DEBUG` re-raises with a stack.
+- Interactive prompts use `node:readline/promises`, which makes the enclosing
+  function `async` — command `run()` signatures are `async (args) => Promise<void>`.
+- No new npm dependencies beyond: commander, nunjucks, yaml.
+- Tests are vitest, in `src/lib/__tests__/<name>.test.ts`.
+
+## Behavior rules
+
+- Keep comments that explain *why*; drop line-by-line *what* comments.
+- `gate.ts` is deliberately dependency-light (it backs a PreToolUse hook with a
+  cold-start budget): it must not import commander/yaml/nunjucks, and must stay
+  runnable directly via `node dist/lib/gate.js` — it has a `main()` guard.

package/README.md

@@ -1,5 +1,59 @@
-# Werkmeister (w9r)
+# sandbox
 
-Name reserved. Werkmeister is the new name of the multi-feature concurrent development
-orchestrator currently published as `@jbbz-sandbox/sandbox-cli`. This placeholder will
-be replaced by the real package when the rename ships.
+A multi-feature concurrent development orchestrator: run up to 12 isolated
+feature environments side by side, each with its own containers, ports, and
+ingress hostnames.
+
+## Quick start
+
+```sh
+npm install
+npm run build
+./sandbox --help
+```
+
+`./sandbox` resolves a node runtime (SANDBOX_NODE → PATH → newest nvm) and execs
+`dist/main.js`. `sandbox hooks gate` bypasses the CLI import chain via
+`dist/lib/gate.js` for a fast PreToolUse cold start.
+
+## Tab completion
+
+`sandbox __complete` answers bash's `complete -C` protocol (COMP_LINE/COMP_POINT
+in, candidates on stdout), so both shells share one code path and there is no
+generated completion script to keep in sync — candidates come off the commander
+program itself.
+
+`sandbox setup` installs it into `~/.zshrc` as a managed block (idempotent;
+re-running replaces its own block and nothing else). To wire it up by hand, or
+in bash, which setup does not touch:
+
+```sh
+autoload -Uz compinit && compinit          # zsh only; skip if your rc runs it
+autoload -Uz +X bashcompinit && bashcompinit
+complete -C 'sandbox __complete' sandbox
+```
+
+Completes subcommand names, a command's long flags, and any positional as a
+feature name (`infra` plus the workspaces under the workspaces root).
+
+## Layout
+
+- `src/main.ts` — commander program (subcommand registry + dispatch)
+- `src/commands/` — one module per subcommand (`run(args)` entrypoints)
+- `src/lib/` — shared logic
+- `infra/`, `docs/standards/`, `bin/` — runtime data the CLI consumes as-is
+- `CONVENTIONS.md` — the code conventions used throughout
+- `docs/design.md` — scope and decisions
+
+## Notes
+
+- CLI parsing is commander; templates in `infra/templates/*.njk` render through
+  nunjucks with a small compat layer (`{% do %}`, dict truthiness,
+  `map(attribute=…)`) so they stay shared verbatim with other consumers
+- `sandbox mcp` runs the headless MCP server over stdio. Its source is
+  `apps/mcp`, bundled into `dist/mcp.js` by `esbuild.mjs` so it ships in the npm
+  package. `sandbox dashboard` runs the richer workspaces dashboard from
+  `apps/sandbox-dashboard` (Jira, PRs, MCP Apps UI), which is checkout-only;
+  where that app is absent the verb falls back to the bundled headless server
+- interactive prompts and process-spawn edges are async (`run()` is
+  `async` throughout); core logic stays synchronous

package/bin/generate-certs.sh

@@ -0,0 +1,254 @@
+#!/bin/bash
+# Generate the self-signed TLS certificate the sandbox ingress terminates.
+#
+# The hostnames are NOT hardcoded here. They come from the sandbox ingress
+# config (`ingress.local_domain` / `ingress.remote_domain` in
+# ~/.sandbox/config.yaml, crossed with the routed services in
+# ~/.sandbox/services.yaml) and are passed in by `sandbox setup` via --domain.
+# That way the certificate SANs, the /etc/hosts entries and the Caddy site
+# blocks all derive from one list instead of three hand-synced copies.
+#
+# Standalone use (no CLI): pass --domain yourself, or set WERKMEISTER_INGRESS_HOSTS
+# to a comma/space-separated list. `sandbox setup` is the normal entry point.
+# WERKMEISTER_HOSTS_FILE overrides /etc/hosts (tests). Each WERKMEISTER_* falls back to SANDBOX_*.
+#
+# Usage:
+#   generate-certs.sh [--domain HOST]... [--certs-dir DIR]
+#                     [--no-trust] [--no-hosts] [--force] [--check]
+#
+#   --domain HOST    Hostname to cover (repeatable). Also seeds /etc/hosts.
+#   --certs-dir DIR  Output directory  [$SANDBOX_CERTS_DIR, else ~/.docker/certs]
+#   --no-trust       Skip adding the cert to the macOS System keychain (no sudo)
+#   --no-hosts       Skip the /etc/hosts update (no sudo)
+#   --force          Regenerate even if a certificate already exists
+#   --check          Report only; exit 1 if the cert or /etc/hosts drifted
+#
+# Exit codes: 0 ok / already current, 1 missing-or-stale (--check) or failure.
+
+set -euo pipefail
+
+CERTS_DIR="${WERKMEISTER_CERTS_DIR:-${SANDBOX_CERTS_DIR:-$HOME/.docker/certs}}"
+HOSTS_FILE="${WERKMEISTER_HOSTS_FILE:-${SANDBOX_HOSTS_FILE:-/etc/hosts}}"
+HOSTS_BEGIN="# BEGIN sandbox ingress"
+HOSTS_END="# END sandbox ingress"
+DO_TRUST=true
+DO_HOSTS=true
+FORCE=false
+CHECK_ONLY=false
+DOMAINS=()
+
+# Seed from the env fallback (comma or whitespace separated) before parsing
+# flags, so an explicit --domain adds to it rather than being overridden.
+INGRESS_HOSTS="${WERKMEISTER_INGRESS_HOSTS:-${SANDBOX_INGRESS_HOSTS:-}}"
+if [ -n "$INGRESS_HOSTS" ]; then
+    IFS=', ' read -r -a DOMAINS <<< "$INGRESS_HOSTS"
+fi
+
+while [ $# -gt 0 ]; do
+    case "$1" in
+        --domain)     DOMAINS+=("$2"); shift 2 ;;
+        --domain=*)   DOMAINS+=("${1#*=}"); shift ;;
+        --certs-dir)  CERTS_DIR="$2"; shift 2 ;;
+        --certs-dir=*) CERTS_DIR="${1#*=}"; shift ;;
+        --no-trust)   DO_TRUST=false; shift ;;
+        --no-hosts)   DO_HOSTS=false; shift ;;
+        --force)      FORCE=true; shift ;;
+        --check)      CHECK_ONLY=true; shift ;;
+        -h|--help)    sed -n '2,26p' "$0"; exit 0 ;;
+        *)            echo "Unknown argument: $1" >&2; exit 1 ;;
+    esac
+done
+
+CRT="$CERTS_DIR/localhost.crt"
+KEY="$CERTS_DIR/localhost.key"
+
+# --- SAN list --------------------------------------------------------------
+# localhost always; then each requested host plus a wildcard for its parent
+# domain, so a later service on the same domain is already covered.
+SANS=("DNS:localhost" "DNS:*.localhost" "IP:127.0.0.1")
+seen_wildcards=""
+for domain in ${DOMAINS+"${DOMAINS[@]}"}; do
+    [ -n "$domain" ] || continue
+    SANS+=("DNS:$domain")
+    parent="${domain#*.}"
+    # Only wildcard a real parent domain (a.b.c -> *.b.c), never a bare TLD.
+    if [ "$parent" != "$domain" ] && [ "${parent#*.}" != "$parent" ]; then
+        case " $seen_wildcards " in
+            *" $parent "*) ;;
+            *) SANS+=("DNS:*.$parent"); SANS+=("DNS:$parent")
+               seen_wildcards="$seen_wildcards $parent" ;;
+        esac
+    fi
+done
+
+SAN_STRING="$(IFS=,; echo "${SANS[*]}")"
+
+# Lines in sorted set $1 that are not in sorted set $2, space-separated.
+only_in() { comm -23 <(printf '%s\n' "$1") <(printf '%s\n' "$2") | sed '/^$/d' | tr '\n' ' '; }
+
+# --- check mode ------------------------------------------------------------
+# Stale means the explicit SANs differ from the registry either way: a missing
+# host appears when a service is added, an extra one when a service is removed.
+missing_sans=()
+extra_sans=""
+if [ -f "$CRT" ]; then
+    cert_text="$(openssl x509 -in "$CRT" -noout -ext subjectAltName 2>/dev/null || true)"
+    for domain in ${DOMAINS+"${DOMAINS[@]}"}; do
+        [ -n "$domain" ] || continue
+        parent="${domain#*.}"
+        if ! grep -qF "DNS:$domain" <<< "$cert_text" \
+           && ! grep -qF "DNS:*.$parent" <<< "$cert_text"; then
+            missing_sans+=("$domain")
+        fi
+    done
+    extra_sans="$(only_in \
+        "$(grep -oE 'DNS:[^,[:space:]]+' <<< "$cert_text" | sort -u || true)" \
+        "$(printf '%s\n' "${SANS[@]}" | grep '^DNS:' | sort -u)")"
+    extra_sans="${extra_sans//DNS:/}"
+fi
+
+# Hosts entries this script owns: everything inside the managed block, plus bare
+# `127.0.0.1` lines whose every name sits under an ingress domain — the lines
+# older versions appended before the block existed. Anything else is the user's.
+# `hosts_scan names` prints the owned names; `hosts_scan rest` prints the file
+# without them.
+hosts_scan() {
+    [ -f "$HOSTS_FILE" ] || return 0
+    awk -v mode="$1" -v parents="$seen_wildcards" -v b="$HOSTS_BEGIN" -v e="$HOSTS_END" '
+        BEGIN { n = split(parents, p, " ") }
+        function ingress(h,   i, s) {
+            for (i = 1; i <= n; i++) {
+                s = "." p[i]
+                if (length(h) > length(s) && substr(h, length(h) - length(s) + 1) == s) return 1
+            }
+            return 0
+        }
+        function emit(   i) { if (mode == "names") for (i = 2; i <= NF; i++) print $i }
+        $0 == b { inblock = 1; next }
+        $0 == e { inblock = 0; next }
+        inblock { emit(); next }
+        $1 == "127.0.0.1" && NF > 1 {
+            owned = 1
+            for (i = 2; i <= NF; i++) if (!ingress($i)) owned = 0
+            if (owned) { emit(); next }
+        }
+        mode == "rest" { print }
+    ' "$HOSTS_FILE"
+}
+
+wanted_hosts="$(printf '%s\n' ${DOMAINS+"${DOMAINS[@]}"} | sed '/^$/d' | sort -u)"
+if [ "$DO_HOSTS" = true ]; then
+    owned_hosts="$(hosts_scan names | sort -u)"
+    extra_hosts="$(only_in "$owned_hosts" "$wanted_hosts")"
+    missing_hosts="$(only_in "$wanted_hosts" "$owned_hosts")"
+fi
+
+if [ "$CHECK_ONLY" = true ]; then
+    drift=false
+    if [ ! -f "$CRT" ] || [ ! -f "$KEY" ]; then
+        echo "missing: no certificate at $CRT"
+        drift=true
+    else
+        if [ ${#missing_sans[@]} -gt 0 ]; then
+            echo "stale: certificate does not cover ${missing_sans[*]}"
+            drift=true
+        fi
+        if [ -n "$extra_sans" ]; then
+            echo "stale: certificate has extra SANs ${extra_sans% }"
+            drift=true
+        fi
+    fi
+    if [ -n "${missing_hosts:-}" ]; then
+        echo "stale: $HOSTS_FILE is missing ${missing_hosts% }"
+        drift=true
+    fi
+    if [ -n "${extra_hosts:-}" ]; then
+        echo "stale: $HOSTS_FILE has extra entries ${extra_hosts% }"
+        drift=true
+    fi
+    [ "$drift" = true ] && exit 1
+    echo "ok: $CRT covers ${#DOMAINS[@]} ingress hostname(s)"
+    exit 0
+fi
+
+# --- generate --------------------------------------------------------------
+mkdir -p "$CERTS_DIR"
+
+if [ -f "$CRT" ] && [ -f "$KEY" ] && [ "$FORCE" != true ]; then
+    if [ ${#missing_sans[@]} -gt 0 ]; then
+        echo "Certificate at $CRT does not cover: ${missing_sans[*]}"
+        echo "Regenerating to add the missing hostnames..."
+    elif [ -n "$extra_sans" ]; then
+        echo "Certificate at $CRT has SANs no longer routed: ${extra_sans% }"
+        echo "Regenerating to drop them..."
+    else
+        echo "Certificates already exist in $CERTS_DIR and cover every ingress hostname."
+        echo "To regenerate anyway: $0 --force"
+        # Still reconcile /etc/hosts below — a new or removed service changes
+        # its hosts entry even when the wildcard SAN already covered it.
+        FORCE=skip_generate
+    fi
+fi
+
+if [ "$FORCE" != "skip_generate" ]; then
+    echo "Generating self-signed SSL certificate..."
+    echo "  SANs: $SAN_STRING"
+
+    openssl req -x509 -nodes -days 365 -newkey rsa:2048 \
+        -keyout "$KEY" \
+        -out "$CRT" \
+        -subj "/C=US/ST=State/L=City/O=Dev/CN=localhost" \
+        -addext "subjectAltName=$SAN_STRING"
+
+    chmod 600 "$KEY"
+
+    echo ""
+    echo "SSL certificate generated:"
+    echo "  Certificate: $CRT"
+    echo "  Private Key: $KEY"
+    echo ""
+    echo "Note: Docker Compose mounts these into Caddy via \$SANDBOX_CERTS_DIR."
+
+    # Trust the certificate on macOS.
+    if [ "$DO_TRUST" = true ] && [[ "$OSTYPE" == "darwin"* ]]; then
+        echo ""
+        echo "Trusting the certificate in the System keychain (requires sudo)..."
+        if sudo security add-trusted-cert -d -r trustRoot \
+                -k /Library/Keychains/System.keychain "$CRT"; then
+            echo "Certificate trusted. Restart your browser for it to take effect."
+        else
+            echo "Failed to trust the certificate automatically. To do it manually:"
+            echo "  sudo security add-trusted-cert -d -r trustRoot -k /Library/Keychains/System.keychain $CRT"
+        fi
+    elif [ "$DO_TRUST" = true ]; then
+        echo ""
+        echo "Not macOS — trust $CRT with your platform's certificate store to"
+        echo "avoid browser warnings."
+    fi
+fi
+
+# --- /etc/hosts ------------------------------------------------------------
+# Rebuild the managed block from the registry so removed services drop out;
+# lines outside it are left exactly as they were.
+if [ "$DO_HOSTS" = true ] && [ ${#DOMAINS[@]} -gt 0 ]; then
+    echo ""
+    echo "Pointing ingress hostnames at 127.0.0.1 in $HOSTS_FILE..."
+    rendered="$(
+        hosts_scan rest
+        echo "$HOSTS_BEGIN"
+        while read -r domain; do echo "127.0.0.1 $domain"; done <<< "$wanted_hosts"
+        echo "$HOSTS_END"
+    )"
+    if [ -f "$HOSTS_FILE" ] && [ "$rendered" = "$(cat "$HOSTS_FILE")" ]; then
+        echo "No changes needed to $HOSTS_FILE."
+    else
+        for domain in $missing_hosts; do echo "  + $domain"; done
+        for domain in $extra_hosts; do echo "  - $domain"; done
+        if [ -w "$HOSTS_FILE" ]; then
+            printf '%s\n' "$rendered" > "$HOSTS_FILE"
+        else
+            printf '%s\n' "$rendered" | sudo tee "$HOSTS_FILE" > /dev/null
+        fi
+        echo "$HOSTS_FILE updated."
+    fi
+fi

package/dist/lib/gate.js

@@ -0,0 +1,278 @@
+import { createRequire as __sandboxCreateRequire } from "node:module";
+const require = __sandboxCreateRequire(import.meta.url);
+
+// ../../packages/sandbox-core/dist/gate.js
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
+
+// ../../packages/sandbox-core/dist/dot_dir.js
+import * as fs from "node:fs";
+import * as path from "node:path";
+var DOT_DIRS = [".werkmeister", ".sandbox"];
+function dotDir(parent) {
+  const found = DOT_DIRS.find((d) => fs.existsSync(path.join(parent, d)));
+  return path.join(parent, found ?? DOT_DIRS[0]);
+}
+
+// ../../packages/sandbox-core/dist/gate.js
+var _PRECEDENCE_TEXT = "Precedence: these standards' rules win over conflicting task framing \u2014 if a rule and the task clash, follow the rule and say so (invariant: apply it and write a `decision` note; rule: surface the conflict in one line, then apply). This gate fires once; your retry will proceed.";
+var _PHASE_ENTRY_TEXT = "Standards gate: invoke `sb-implement` before coding \u2014 it loads the universal base (ponytail + comments + engineering) and the workspace notes. Then retry this edit.";
+function _translate(pat) {
+  let res = "";
+  let i = 0;
+  const n = pat.length;
+  while (i < n) {
+    const c = pat[i];
+    i += 1;
+    if (c === "*") {
+      res += ".*";
+    } else if (c === "?") {
+      res += ".";
+    } else if (c === "[") {
+      let j = i;
+      if (j < n && pat[j] === "!")
+        j += 1;
+      if (j < n && pat[j] === "]")
+        j += 1;
+      while (j < n && pat[j] !== "]")
+        j += 1;
+      if (j >= n) {
+        res += "\\[";
+      } else {
+        let stuff = pat.slice(i, j).replace(/\\/g, "\\\\");
+        i = j + 1;
+        if (stuff.startsWith("!"))
+          stuff = "^" + stuff.slice(1);
+        else if (stuff.startsWith("^"))
+          stuff = "\\" + stuff;
+        res += `[${stuff}]`;
+      }
+    } else {
+      res += c.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+    }
+  }
+  return `^(?:${res})$`;
+}
+function fnmatch(name, pat) {
+  return new RegExp(_translate(pat), "s").test(name);
+}
+function findWorkspaceRoot(start) {
+  let directory = path2.resolve(start);
+  while (true) {
+    if (_isDir(dotDir(directory))) {
+      return directory;
+    }
+    const parent = path2.dirname(directory);
+    if (parent === directory) {
+      return null;
+    }
+    directory = parent;
+  }
+}
+function _isDir(p) {
+  try {
+    return fs2.statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function _isFile(p) {
+  try {
+    return fs2.statSync(p).isFile();
+  } catch {
+    return false;
+  }
+}
+function _isDict(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function loadManifest(workspace) {
+  const manifestPath = path2.join(dotDir(workspace), "standards.json");
+  if (!_isFile(manifestPath)) {
+    return null;
+  }
+  let data;
+  try {
+    data = JSON.parse(fs2.readFileSync(manifestPath, "utf8"));
+  } catch {
+    return null;
+  }
+  return _isDict(data) ? data : null;
+}
+function _statePath(workspace, sessionId) {
+  return path2.join(dotDir(workspace), ".gate", `${sessionId}.json`);
+}
+function _loadState(workspace, sessionId) {
+  const statePath = _statePath(workspace, sessionId);
+  if (!_isFile(statePath)) {
+    return {};
+  }
+  let data;
+  try {
+    data = JSON.parse(fs2.readFileSync(statePath, "utf8"));
+  } catch {
+    return null;
+  }
+  return _isDict(data) ? data : null;
+}
+function _saveState(workspace, sessionId, state) {
+  try {
+    const statePath = _statePath(workspace, sessionId);
+    fs2.mkdirSync(path2.dirname(statePath), { recursive: true });
+    fs2.writeFileSync(statePath, JSON.stringify(state));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function _sorted(values) {
+  return [...values].sort();
+}
+function _noteStatus(text) {
+  const block = /^---\r?\n([\s\S]*?)\r?\n---/.exec(text);
+  if (!block) {
+    return void 0;
+  }
+  const status = /^status:\s*["']?([^\s"'#]+)/m.exec(block[1]);
+  return status ? status[1].toLowerCase() : null;
+}
+function _phaseGateSatisfied(workspace, gate) {
+  const note = String(gate["note"] ?? "");
+  if (!/^[a-z]+$/.test(note)) {
+    return true;
+  }
+  const want = gate["status"] ? String(gate["status"]).toLowerCase() : null;
+  const dir = path2.join(dotDir(workspace), "notes");
+  let names;
+  try {
+    names = fs2.readdirSync(dir);
+  } catch (exc) {
+    return exc.code !== "ENOENT";
+  }
+  const pattern = new RegExp(`^\\d{3}-${note}-.+\\.md$`);
+  for (const name of names) {
+    if (!pattern.test(name)) {
+      continue;
+    }
+    let text;
+    try {
+      text = fs2.readFileSync(path2.join(dir, name), "utf8");
+    } catch {
+      return true;
+    }
+    const status = _noteStatus(text);
+    if (status === void 0) {
+      return true;
+    }
+    if (status === "superseded" || status === "graduated") {
+      continue;
+    }
+    if (want === null || status === want) {
+      return true;
+    }
+  }
+  return false;
+}
+function _phaseGateText(gate) {
+  const note = String(gate["note"]);
+  if (gate["status"]) {
+    const status = String(gate["status"]);
+    return `Phase gate: no \`${note}\` note in \`.sandbox/notes/\` has \`status: ${status}\`, so source edits wait for an approved design. Invoke \`sb-research\`, present the design to the user, and when they approve write \`NNN-${note}-<slug>.md\` with \`status: ${status}\` recording what was approved. Then retry this edit. Edits under \`.sandbox/\` are not gated.`;
+  }
+  return `Phase gate: no \`${note}\` note in \`.sandbox/notes/\` names the root cause yet. Invoke \`sb-research\`, reproduce the problem, and write \`NNN-${note}-<slug>.md\` stating the root cause. Then retry this edit. Edits under \`.sandbox/\` are not gated.`;
+}
+function decide(workspaceStart, sessionId, filePath) {
+  if (!sessionId || sessionId.includes("/") || sessionId.includes("..")) {
+    return null;
+  }
+  const workspace = findWorkspaceRoot(workspaceStart);
+  if (workspace === null) {
+    return null;
+  }
+  const manifest = loadManifest(workspace);
+  if (manifest === null) {
+    return null;
+  }
+  const state = _loadState(workspace, sessionId);
+  if (state === null) {
+    return null;
+  }
+  const relPath = filePath ? path2.relative(workspace, filePath) : "";
+  const phaseGate = manifest["phase_gate"];
+  if (_isDict(phaseGate) && relPath && relPath !== ".." && !relPath.startsWith(".." + path2.sep) && !path2.isAbsolute(relPath) && !DOT_DIRS.some((d) => relPath.startsWith(d + path2.sep)) && !_phaseGateSatisfied(workspace, phaseGate)) {
+    return _phaseGateText(phaseGate);
+  }
+  const delivered = new Set(Array.isArray(state["delivered"]) ? state["delivered"] : []);
+  const needsPhaseEntry = !state["phase_entry_delivered"];
+  let domain = null;
+  const domains = _isDict(manifest["domains"]) ? manifest["domains"] : {};
+  for (const name of _sorted(Object.keys(domains))) {
+    const meta = domains[name];
+    if (delivered.has(name) || !_isDict(meta)) {
+      continue;
+    }
+    const globs = Array.isArray(meta["applies_to"]) ? meta["applies_to"] : [];
+    if (globs.some((glob) => fnmatch(relPath, String(glob)))) {
+      domain = name;
+      break;
+    }
+  }
+  if (!needsPhaseEntry && domain === null) {
+    return null;
+  }
+  const parts = [];
+  if (needsPhaseEntry) {
+    parts.push(_PHASE_ENTRY_TEXT);
+  }
+  if (domain !== null) {
+    const meta = domains[domain];
+    const summary = String(_isDict(meta) && meta["summary"] || "").trim();
+    let domainText = `Standards gate: you are editing a path governed by the \`${domain}\` standard, which has not been loaded this session. Invoke the \`sb-${domain}-standard\` skill, then retry this edit.`;
+    if (summary) {
+      domainText += ` Summary: ${summary}.`;
+    }
+    parts.push(domainText);
+  }
+  parts.push(_PRECEDENCE_TEXT);
+  const newState = {
+    phase_entry_delivered: true,
+    delivered: _sorted(domain ? /* @__PURE__ */ new Set([...delivered, domain]) : delivered)
+  };
+  if (!_saveState(workspace, sessionId, newState)) {
+    return null;
+  }
+  return parts.join("\n");
+}
+function main() {
+  let data;
+  try {
+    const raw = process.stdin.isTTY ? "" : fs2.readFileSync(0, "utf8");
+    const parsed = raw.trim() ? JSON.parse(raw) : {};
+    data = _isDict(parsed) ? parsed : {};
+  } catch {
+    data = {};
+  }
+  const sessionId = String(data["session_id"] || "");
+  const toolInput = data["tool_input"];
+  const filePath = String(_isDict(toolInput) && toolInput["file_path"] || "");
+  const start = String(data["cwd"] || process.cwd());
+  let reason;
+  try {
+    reason = decide(start, sessionId, filePath);
+  } catch {
+    reason = null;
+  }
+  if (reason) {
+    console.log(JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: "PreToolUse",
+        permissionDecision: "deny",
+        permissionDecisionReason: reason
+      }
+    }));
+  }
+}
+
+// src/lib/gate.ts
+main();
+//# sourceMappingURL=gate.js.map