@mseep/open-computer-use 1.0.0

package/scripts/docs-lint/gitignored-ref-detector.sh

@@ -0,0 +1,122 @@
+#!/usr/bin/env bash
+# SPDX-License-Identifier: FSL-1.1-Apache-2.0
+# Copyright (c) 2025 Open Computer Use Contributors
+#
+# gitignored-ref-detector — fail when a doc references a path that the
+# reader cannot open from a clean git clone.
+#
+# The rule: docs under `docs/architecture/` and `docs/future-architecture/`
+# are reference material that someone who cloned the repo must be able to
+# follow. If a doc cites a path that is gitignored, the reader sees a dead
+# link and the architecture becomes self-referential to a private working
+# directory.
+#
+# The set of local-only directory prefixes to treat as private is supplied
+# out-of-band via the LOCAL_REF_DIRS environment variable (colon-separated).
+# It defaults to empty, in which case only `git check-ignore` drives the
+# finding. No literal local directory name is embedded in this script.
+#
+# This linter walks every markdown file under the doc roots, extracts file
+# paths (anything that looks like `path/to/file.ext`), and fails if any of
+# those paths is gitignored.
+#
+# Allowed exceptions (implemented below):
+#   - paths that resolve to URLs (http:// https://)
+#   - absolute non-repo paths (starting with `/`)
+#   - command-fragment heuristic for /dev/null, /proc/*, /tmp/*, /etc/*,
+#     /var/*, /home/*, /usr/* — these are filesystem paths in commands,
+#     not repo references
+#
+# Currently not separately filtered (rely on `git check-ignore` instead):
+#   - paths under `docs/` (docs-tree paths are checked like any other —
+#     if a doc path is gitignored, that is itself a finding)
+#   - paths under `.planning/` (gitignored by repo policy; would correctly
+#     fire here, but `.planning/` is not in the doc roots scanned, so
+#     references to it from inside `docs/` would correctly fail)
+#
+# Run from repo root:  scripts/docs-lint/gitignored-ref-detector.sh
+
+set -euo pipefail
+
+ROOT="$(git rev-parse --show-toplevel)"
+cd "$ROOT"
+
+DOC_ROOTS=(
+  docs/architecture
+  docs/future-architecture
+)
+
+# Local-only directory prefixes (colon-separated), supplied out-of-band.
+# Defaults to empty: with no value set, only `git check-ignore` drives the
+# finding and this extra prefix match is a no-op.
+LOCAL_REF_DIRS="${LOCAL_REF_DIRS:-}"
+IFS=':' read -r -a LOCAL_PREFIXES <<< "$LOCAL_REF_DIRS"
+
+fail=0
+total_refs=0
+
+for root in "${DOC_ROOTS[@]}"; do
+  [ -d "$root" ] || continue
+
+  while IFS= read -r -d '' doc; do
+    # Extract candidate filesystem paths:
+    #   - inside backticks
+    #   - markdown links [text](path)
+    #   - bare path/with/slashes.ext occurrences
+    # Filter to things that look like a real path (contain `/` and end in
+    # a known extension OR look like a directory path).
+    candidates=$(grep -ohE '(\[[^]]*\]\(([^)]+)\))|(`[^`]+`)|([A-Za-z0-9_./-]+\.(md|mmd|yaml|yml|json|sh|py|go|rs|ts|tsx|js|jsx|toml|conf|txt|zip|html|svg|png|jpg))' "$doc" \
+      | sed -E 's/^\[[^]]*\]\(([^)]+)\)$/\1/' \
+      | sed -E 's/^`(.+)`$/\1/' \
+      | grep -vE '^https?://' \
+      | grep -vE '^#' \
+      | grep -E '/' \
+      | sort -u || true)
+
+    while IFS= read -r path; do
+      [ -z "$path" ] && continue
+      # strip line-number suffix like file.md:42 or file.md#anchor
+      clean=$(echo "$path" | sed -E 's/[:#].*$//')
+      # strip leading ./ or ../
+      clean=$(echo "$clean" | sed -E 's|^\./||; s|^(\.\./)+||')
+      # skip URLs and absolute non-repo paths
+      case "$clean" in
+        http*|/*) continue ;;
+      esac
+      # skip well-known non-path matches (heuristic: command-like fragments)
+      case "$clean" in
+        */dev/null|*/proc/*|*/tmp/*|*/etc/*|*/var/*|*/home/*|*/usr/*) continue ;;
+      esac
+
+      total_refs=$((total_refs + 1))
+
+      # Local-only prefix match (only when LOCAL_REF_DIRS is set).
+      for prefix in "${LOCAL_PREFIXES[@]}"; do
+        [ -z "$prefix" ] && continue
+        case "$clean" in
+          "$prefix"|"$prefix"/*)
+            echo "FAIL: $doc references local-only path: $clean"
+            fail=1
+            ;;
+        esac
+      done
+
+      # `git check-ignore` exits 0 if path is gitignored
+      if git check-ignore -q "$clean" 2>/dev/null; then
+        echo "FAIL: $doc references gitignored path: $clean"
+        fail=1
+      fi
+    done <<< "$candidates"
+  done < <(find "$root" -type f -name '*.md' -print0)
+done
+
+if [ "$fail" -eq 1 ]; then
+  echo ""
+  echo "gitignored-ref-detector: at least one doc references a path the reader"
+  echo "cannot open. Either remove the reference, replace it with a public"
+  echo "citation (e.g. a regulator URL, a public Anthropic doc URL, an in-repo"
+  echo "file under docs/), or move the cited content into the repo."
+  exit 1
+fi
+
+echo "gitignored-ref-detector: scanned $total_refs refs, all reachable."

package/scripts/docs-lint/identity-email-detector.sh

@@ -0,0 +1,48 @@
+#!/usr/bin/env bash
+# SPDX-License-Identifier: FSL-1.1-Apache-2.0
+# Copyright (c) 2025 Open Computer Use Contributors
+#
+# Identity-email detector — the project commits and authors under the
+# Wide-Moat org identity, not a personal address.
+#
+#   banned:    i@yambr.com
+#   canonical: developer@widemoat.ai
+#
+# This gate scans tracked file content (docs, code, configs) for the banned
+# address and tells the author to rewrite it. Commit *metadata* (author /
+# committer email) is enforced separately by the pre-push hook; this script
+# only covers the file-content surface so the same rule holds in CI.
+#
+# Exits 1 if the banned address appears in any tracked file.
+
+set -uo pipefail
+
+ROOT="$(git rev-parse --show-toplevel)"
+cd "$ROOT"
+
+BANNED="i@yambr.com"
+CANONICAL="developer@widemoat.ai"
+
+# Search tracked files only; never descend into references/ (vendored repos)
+# or .git. -I skips binary files. Fixed-string match so the dot is literal.
+# The two policy scripts (this detector and the pre-push hook) name the banned
+# address on purpose, to define the rule — exclude them so the gate does not
+# flag its own definition.
+hits="$(git grep -InF "$BANNED" -- \
+  ':(exclude)references/**' \
+  ':(exclude)*.sample' \
+  ':(exclude)scripts/docs-lint/identity-email-detector.sh' \
+  ':(exclude)scripts/githooks/pre-push' \
+  2>/dev/null || true)"
+
+if [ -n "$hits" ]; then
+  echo "-----------------------------------------------------------------"
+  echo "BLOCKED: the personal address '$BANNED' appears in tracked files."
+  echo "Rewrite it to the project identity: $CANONICAL"
+  echo ""
+  echo "$hits" | sed 's/^/  /'
+  echo "-----------------------------------------------------------------"
+  exit 1
+fi
+
+exit 0

package/scripts/docs-lint/test-linters.sh

@@ -0,0 +1,354 @@
+#!/usr/bin/env bash
+# SPDX-License-Identifier: FSL-1.1-Apache-2.0
+# Copyright (c) 2025 Open Computer Use Contributors
+#
+# Linter self-test: prove each gate catches the violation it's supposed to.
+#
+# Creates temporary fixtures, runs the matching detection logic against them,
+# and asserts each gate correctly flags / accepts the fixture. Cleans up.
+#
+# Run from repo root: scripts/docs-lint/test-linters.sh
+
+set -uo pipefail
+
+ROOT="$(git rev-parse --show-toplevel)"
+cd "$ROOT"
+
+TMP="$(mktemp -d)"
+trap 'rm -rf "$TMP"' EXIT
+
+pass=0
+fail=0
+
+ok()   { echo "  ok:   $1"; pass=$((pass + 1)); }
+err()  { echo "  FAIL: $1"; fail=$((fail + 1)); }
+
+# -------- wc-budget --------
+echo "Testing wc-budget.sh:"
+
+big_adr="$TMP/big.md"
+{
+  echo "---"; echo "status: draft"; echo "---"
+  for i in $(seq 1 250); do echo "line $i"; done
+} > "$big_adr"
+
+lines=$(wc -l < "$big_adr" | tr -d ' ')
+if (( lines > 200 )); then
+  ok "ADR cap (200) would block file with $lines lines"
+else
+  err "wc fixture didn't exceed cap"
+fi
+
+# -------- ai-slop-detector --------
+echo "Testing ai-slop-detector.sh:"
+
+slop_conclusion="$TMP/slop_conclusion.md"
+cat > "$slop_conclusion" <<'EOF'
+## Conclusion
+
+text
+EOF
+if grep -qE '^##+ (Conclusion|Summary|In conclusion|TL;DR)$' "$slop_conclusion"; then
+  ok "Conclusion-section regex detects short-doc summary"
+else
+  err "Conclusion regex didn't match fixture"
+fi
+
+slop_toc="$TMP/slop_toc.md"
+cat > "$slop_toc" <<'EOF'
+## Table of Contents
+
+- a
+EOF
+if grep -qE '^##+ (Table of [Cc]ontents|TOC|Contents)$' "$slop_toc"; then
+  ok "TOC regex detects short-doc TOC"
+else
+  err "TOC regex didn't match fixture"
+fi
+
+slop_stub="$TMP/slop_stub.md"
+cat > "$slop_stub" <<'EOF'
+## Stub
+
+## Next section
+
+content
+EOF
+result=$(awk '
+  /^##+ / {
+    cur=$0; line=NR
+    while ((getline next_line) > 0) {
+      if (next_line ~ /^[ \t]*$/) continue
+      if (next_line ~ /^##+ /) { print "HIT:" line; exit }
+      break
+    }
+  }
+' "$slop_stub")
+if [[ "$result" == HIT:* ]]; then
+  ok "stub-heading detection works"
+else
+  err "stub-heading regex didn't catch fixture"
+fi
+
+# bank-as-framing fixture: a framing use must flag, a named example must pass.
+slop_bank="$TMP/slop_bank.md"
+cat > "$slop_bank" <<'EOF'
+The bank already runs an audited store, so the platform targets banks.
+EOF
+bank_re="bank's|\bthe bank\b|\ba bank\b|targets? banks|bank-(required|grade|specific|facing|side)|bank (infosec|ciso|reviewer|procurement|architect|auditor)"
+bank_allow='tier-1 (us or eu )?bank|tier-1 banks|US or EU bank|retail-banking|banking convention|banking-vendor convention'
+if grep -nEi "$bank_re" "$slop_bank" | grep -vEi "$bank_allow" | grep -q .; then
+  ok "bank-as-framing detection works"
+else
+  err "bank-framing regex didn't catch fixture"
+fi
+slop_bank_ok="$TMP/slop_bank_ok.md"
+cat > "$slop_bank_ok" <<'EOF'
+The capability ceiling targets a tier-1 US or EU bank as the named example.
+EOF
+if grep -nEi "$bank_re" "$slop_bank_ok" | grep -vEi "$bank_allow" | grep -q .; then
+  err "bank-framing regex wrongly flagged the tier-1 named example"
+else
+  ok "bank named-example (tier-1) correctly accepted"
+fi
+
+# SAML-as-surface fixture: asserting SAML must flag, a federation clause must pass.
+slop_saml="$TMP/slop_saml.md"
+cat > "$slop_saml" <<'EOF'
+Human action requires SAML/OIDC on the full shelf.
+EOF
+saml_allow='SAML-only (customer )?(idp|pam)|federates? in through (dex|keycloak)|never an OCU SAML|through Dex or Keycloak'
+if grep -nEi '\bSAML\b' "$slop_saml" | grep -vEi "$saml_allow" | grep -q .; then
+  ok "SAML-as-surface detection works"
+else
+  err "SAML regex didn't catch fixture"
+fi
+slop_saml_ok="$TMP/slop_saml_ok.md"
+cat > "$slop_saml_ok" <<'EOF'
+A SAML-only customer IdP federates in through Dex or Keycloak, never an OCU SAML surface.
+EOF
+if grep -nEi '\bSAML\b' "$slop_saml_ok" | grep -vEi "$saml_allow" | grep -q .; then
+  err "SAML regex wrongly flagged the federation clause"
+else
+  ok "SAML federation clause correctly accepted"
+fi
+
+# -------- ascii-diagram-detector --------
+echo "Testing ascii-diagram-detector.sh:"
+
+ascii_fixture="$TMP/ascii.md"
+cat > "$ascii_fixture" <<'EOF'
+Box-drawing:
+
+┌──────┐
+│ box  │
+└──────┘
+EOF
+
+if python3 -c "
+import re, sys
+pat = re.compile(r'[─-╿▀-▟]')
+with open('$ascii_fixture') as f:
+    sys.exit(0 if any(pat.search(l) for l in f) else 1)
+"; then
+  ok "Unicode box-drawing detected in fixture"
+else
+  err "ascii fixture not detected"
+fi
+
+table_fixture="$TMP/table.md"
+cat > "$table_fixture" <<'EOF'
+| a | b |
+|---|---|
+| 1 | 2 |
+EOF
+
+if python3 -c "
+import re, sys
+pat = re.compile(r'[─-╿▀-▟]')
+with open('$table_fixture') as f:
+    sys.exit(1 if any(pat.search(l) for l in f) else 0)
+"; then
+  ok "Markdown table not flagged as ASCII diagram"
+else
+  err "Markdown table false-positive"
+fi
+
+# -------- front-matter-validator --------
+echo "Testing front-matter-validator.sh:"
+
+nofm="$TMP/nofm.md"
+echo "Just text. No YAML." > "$nofm"
+
+if python3 -c "
+import re, sys, pathlib
+text = pathlib.Path('$nofm').read_text()
+stripped = re.sub(r'^(?:<!--.*?-->\s*\n)+', '', text, flags=re.DOTALL)
+sys.exit(1 if stripped.startswith('---') else 0)
+"; then
+  ok "missing-front-matter detected"
+else
+  err "missing-FM fixture wasn't caught"
+fi
+
+partial_fm="$TMP/partial.md"
+cat > "$partial_fm" <<'EOF'
+---
+status: draft
+owner: "@x"
+---
+content
+EOF
+
+if python3 -c "
+import re, sys, pathlib
+text = pathlib.Path('$partial_fm').read_text()
+stripped = re.sub(r'^(?:<!--.*?-->\s*\n)+', '', text, flags=re.DOTALL)
+m = re.match(r'^---\n(.*?)\n---', stripped, flags=re.DOTALL)
+body = m.group(1)
+fields = {}
+for line in body.splitlines():
+    if ':' in line and not line.startswith(' '):
+        k, _, v = line.partition(':')
+        fields[k.strip()] = v.strip().strip('\"').strip(\"'\")
+required = ['status', 'last-reviewed', 'owner', 'applies-to']
+missing = [k for k in required if k not in fields or not fields[k]]
+sys.exit(0 if missing else 1)
+"; then
+  ok "missing-field detection works"
+else
+  err "partial FM wasn't caught"
+fi
+
+# -------- architecture-tree-whitelist --------
+echo "Testing architecture-tree-whitelist.sh:"
+
+# Run against an isolated fixture tree so we don't disturb the real
+# docs/architecture/. Invoke the same segment-aware matcher the linter
+# uses, so a future regression that swaps it back for plain fnmatch
+# (which lets `*` cross `/`) is caught here.
+tree_root="$TMP/atree/docs/architecture"
+mkdir -p "$tree_root/adr" "$tree_root/diagrams" "$tree_root/components" \
+         "$tree_root/compliance/sub"
+
+# Allowed files.
+touch "$tree_root/README.md"
+touch "$tree_root/adr/0001-foo.md"
+touch "$tree_root/diagrams/c4.mmd"
+touch "$tree_root/components/01-control-plane.md"
+touch "$tree_root/compliance/soc2-mapping.md"
+
+# Disallowed files.
+touch "$tree_root/notes.txt"                          # stray scratch note
+touch "$tree_root/LAYER-0-VERIFICATION.md"            # AI snapshot
+touch "$tree_root/diagrams/screenshot.png"            # binary in diagrams
+touch "$tree_root/compliance/sub/x-mapping.md"        # nested-path edge case:
+                                                       # plain fnmatch would
+                                                       # accept this under
+                                                       # compliance/*-mapping.md
+
+allow_list=(
+  "README.md"
+  "adr/[0-9][0-9][0-9][0-9]-*.md"
+  "diagrams/*.mmd"
+  "components/[0-9][0-9]-*.md"
+  "compliance/*-mapping.md"
+)
+violations=$(
+  cd "$TMP/atree" && python3 - "${allow_list[@]}" <<'PY'
+import fnmatch, pathlib, sys
+allow = sys.argv[1:]
+root = pathlib.Path("docs/architecture")
+
+def match(rel: str, pat: str) -> bool:
+    rp = rel.split("/")
+    pp = pat.split("/")
+    if len(rp) != len(pp):
+        return False
+    return all(fnmatch.fnmatchcase(r, p) for r, p in zip(rp, pp))
+
+bad = []
+for p in root.rglob("*"):
+    if not p.is_file():
+        continue
+    rel = p.relative_to(root).as_posix()
+    if not any(match(rel, g) for g in allow):
+        bad.append(rel)
+print("\n".join(sorted(bad)))
+PY
+)
+
+want_bad=(
+  "LAYER-0-VERIFICATION.md"
+  "compliance/sub/x-mapping.md"
+  "diagrams/screenshot.png"
+  "notes.txt"
+)
+all_caught=1
+for needle in "${want_bad[@]}"; do
+  if ! grep -qxF "$needle" <<<"$violations"; then
+    all_caught=0
+    err "tree-whitelist missed expected violation: $needle"
+  fi
+done
+if (( all_caught )); then
+  ok "tree-whitelist catches stray notes, AI snapshots, binaries, nested-path edge case"
+fi
+
+# Allowed files must NOT appear in violations.
+for needle in \
+  "README.md" \
+  "adr/0001-foo.md" \
+  "diagrams/c4.mmd" \
+  "components/01-control-plane.md" \
+  "compliance/soc2-mapping.md"
+do
+  if grep -qxF "$needle" <<<"$violations"; then
+    err "tree-whitelist false-positive on legitimate file: $needle"
+  fi
+done
+ok "tree-whitelist accepts files that match allowed patterns"
+
+# -------- identity-email-detector --------
+echo "Testing identity-email-detector.sh:"
+
+# Run the detector end-to-end against a throwaway git repo, so the test covers
+# the script's real behaviour (tracked-file scan, path excludes, git invocation,
+# exit code) rather than re-implementing its grep. The banned address is
+# assembled from parts so the literal never appears in this tracked file (which
+# would itself trip the detector it tests).
+banned="i@yambr$(printf '%s' .com)"
+canonical="developer@widemoat.ai"
+detector="$ROOT/scripts/docs-lint/identity-email-detector.sh"
+
+# Fixture repo with one tracked file carrying the banned address.
+fixture="$TMP/identity-fixture"
+git init -q "$fixture"
+git -C "$fixture" config user.email test@example.com
+git -C "$fixture" config user.name test
+printf 'contact %s for help\n' "$banned" > "$fixture/notes.md"
+git -C "$fixture" add notes.md
+git -C "$fixture" commit -q -m fixture
+
+if ( cd "$fixture" && bash "$detector" ) >/dev/null 2>&1; then
+  err "identity-email-detector did not flag the banned personal address"
+else
+  ok "identity-email-detector flags the banned personal address"
+fi
+
+# Replace the tracked content with the canonical address and a product URL;
+# neither must trip the detector.
+printf 'contact %s — see https://chat.yambr.com\n' "$canonical" > "$fixture/notes.md"
+git -C "$fixture" commit -q -am clean
+if ( cd "$fixture" && bash "$detector" ) >/dev/null 2>&1; then
+  ok "identity-email-detector accepts the canonical address and yambr.com URLs"
+else
+  err "identity-email-detector false-positives on the canonical address or a product URL"
+fi
+
+# -------- Summary --------
+echo
+echo "Linter self-test: $pass passed, $fail failed."
+if (( fail > 0 )); then
+  exit 1
+fi

package/scripts/docs-lint/wc-budget.sh

@@ -0,0 +1,61 @@
+#!/usr/bin/env bash
+# SPDX-License-Identifier: FSL-1.1-Apache-2.0
+# Copyright (c) 2025 Open Computer Use Contributors
+#
+# Line-count budget enforcer for architecture docs.
+#
+# Per CLAUDE.md "Documentation discipline":
+#   - ADR ≤ 200 lines (under docs/architecture/adr/, excluding README/template)
+#   - Component spec ≤ 600 lines (under docs/architecture/components/, excluding README/template)
+#   - MANIFESTO.md ≤ 400 lines
+#
+# Exits 1 if any cap is exceeded.
+
+set -euo pipefail
+
+ROOT="$(git rev-parse --show-toplevel)"
+cd "$ROOT"
+
+fail=0
+
+check_cap() {
+  local file="$1" cap="$2" kind="$3"
+  if [[ ! -f "$file" ]]; then
+    return 0
+  fi
+  local lines
+  lines=$(wc -l < "$file" | tr -d ' ')
+  if (( lines > cap )); then
+    echo "FAIL: $kind cap exceeded: $file = $lines lines (cap $cap)"
+    fail=1
+  fi
+}
+
+# MANIFESTO.md (single file).
+check_cap "docs/architecture/MANIFESTO.md" 400 "MANIFESTO"
+
+# All ADRs except the template and the README.
+while IFS= read -r -d '' f; do
+  base="$(basename "$f")"
+  if [[ "$base" == "README.md" || "$base" == "0000-template.md" ]]; then
+    continue
+  fi
+  check_cap "$f" 200 "ADR"
+done < <(find docs/architecture/adr -name '*.md' -print0 2>/dev/null)
+
+# All component specs except the template.
+while IFS= read -r -d '' f; do
+  base="$(basename "$f")"
+  if [[ "$base" == "0000-template.md" ]]; then
+    continue
+  fi
+  check_cap "$f" 600 "component-spec"
+done < <(find docs/architecture/components -name '*.md' -print0 2>/dev/null)
+
+if (( fail )); then
+  echo
+  echo "Hint: split the doc, move detail into a linked ADR, or trim prose."
+  exit 1
+fi
+
+echo "wc-budget: OK"

package/scripts/githooks/pre-push

@@ -0,0 +1,75 @@
+#!/usr/bin/env bash
+# SPDX-License-Identifier: FSL-1.1-Apache-2.0
+# Copyright (c) 2025 Open Computer Use Contributors
+#
+# Versioned pre-push policy. Git does not run this copy directly — hooks live
+# in .git/hooks/, which is not tracked. Install it once per clone:
+#
+#   ln -sf ../../scripts/githooks/pre-push .git/hooks/pre-push
+#
+# (or copy it). CONTRIBUTING.md documents the one-line install. This file is
+# the source of truth; the installed copy must match it.
+#
+# Two gates, both blocking:
+#   1. .planning/ guard — never push planning/roadmap/phase artefacts to the
+#      public GitHub remote.
+#   2. Documentation identity gate — the personal address i@yambr.com must not
+#      appear in tracked file content; rewrite it to developer@widemoat.ai.
+#      (This checks file CONTENT only, not commit author/committer metadata.)
+
+set -euo pipefail
+
+remote_name="$1"
+remote_url="$2"
+
+z40=$(printf '%040d' 0)
+exit_code=0
+
+# Recognise the public remote by URL host.
+case "$remote_url" in
+    *github.com*) is_public=true ;;
+    *)            is_public=false ;;
+esac
+
+# ---- Gate 1: .planning/ guard (public remote only) --------------------------
+if [ "$is_public" = "true" ]; then
+    while read -r local_ref local_sha remote_ref remote_sha; do
+        [ "$local_sha" = "$z40" ] && continue   # deletion
+
+        if [ "$remote_sha" = "$z40" ]; then
+            range="$local_sha"                  # new branch
+            bad_files=$(git ls-tree -r "$local_sha" --name-only | grep -E '^\.planning/' || true)
+        else
+            range="${remote_sha}..${local_sha}"
+            bad_files=$(git log "$range" --name-only --pretty=format: | grep -E '^\.planning/' | sort -u || true)
+        fi
+
+        if [ -n "$bad_files" ]; then
+            echo "-----------------------------------------------------------------"
+            echo "BLOCKED: this push to $remote_url would include .planning/ files."
+            echo "The public GitHub remote must not carry planning/roadmap/phase"
+            echo "artefacts."
+            echo ""
+            echo "Offending paths in range $range:"
+            echo "$bad_files" | sed 's/^/  /'
+            echo "-----------------------------------------------------------------"
+            exit_code=1
+        fi
+    done
+fi
+
+# ---- Gate 2: banned address in tracked file content -------------------------
+# Run the detector through bash, not as an executable: a checkout that drops the
+# exec bit (no-exec filesystem, archive export) must not silently skip the gate.
+ROOT="$(git rev-parse --show-toplevel)"
+detector="$ROOT/scripts/docs-lint/identity-email-detector.sh"
+if [ -f "$detector" ]; then
+    if ! bash "$detector"; then
+        exit_code=1
+    fi
+else
+    echo "BLOCKED: identity detector missing: $detector"
+    exit_code=1
+fi
+
+exit $exit_code

package/server.json

@@ -0,0 +1,13 @@
+{
+  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
+  "name": "io.github.Wide-Moat/open-computer-use",
+  "title": "Open Computer Use",
+  "version": "0.8.12.6",
+  "description": "Give any LLM its own computer — Docker sandboxes with bash, browser, docs, and sub-agents",
+  "websiteUrl": "https://github.com/Wide-Moat/open-computer-use",
+  "repository": {
+    "url": "https://github.com/Wide-Moat/open-computer-use",
+    "source": "github",
+    "id": "Wide-Moat/open-computer-use"
+  }
+}

package/settings-wrapper/Dockerfile

@@ -0,0 +1,9 @@
+# SPDX-License-Identifier: FSL-1.1-Apache-2.0
+# Copyright (c) 2025 Open Computer Use Contributors
+FROM python:3.12-slim
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+COPY . .
+EXPOSE 8082
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8082"]