@jeger-ai/opengantry 1.0.0

package/templates/.cursor/hooks/gxt-session-start.sh

@@ -0,0 +1,68 @@
+#!/usr/bin/env bash
+# Cursor sessionStart — inject GXT mission scope + runtime env for OpenGantry dogfood.
+set -euo pipefail
+
+ROOT="${CURSOR_PROJECT_DIR:-${CLAUDE_PROJECT_DIR:-$(git rev-parse --show-toplevel 2>/dev/null || echo "")}}"
+if [ -z "$ROOT" ]; then
+  exit 0
+fi
+cd "$ROOT"
+
+MISSION=""
+if MISSION="$(scripts/gxt-resolve-mission.sh 2>/dev/null)"; then
+  :
+else
+  node -e '
+    process.stdout.write(JSON.stringify({
+      additional_context: "No active mission pinned. Ask me to run the Mission Architect protocol (MCP: gxt_draft_legislation) or gapman legislate.",
+    }));
+  '
+  exit 0
+fi
+
+RUNTIME_JSON=""
+if command -v gapman >/dev/null 2>&1; then
+  RUNTIME_JSON="$(gapman runtime env --mission "$MISSION" --json 2>/dev/null || true)"
+elif [ -f "dist/cli/index.js" ]; then
+  RUNTIME_JSON="$(node dist/cli/index.js runtime env --mission "$MISSION" --json 2>/dev/null || true)"
+fi
+
+if [ -z "$RUNTIME_JSON" ]; then
+  node -e '
+    process.stdout.write(JSON.stringify({
+      additional_context: "GXT: gapman not built — run npm ci && npm run build, then scripts/gxt-pin-mission.sh <mission>",
+    }));
+  '
+  exit 0
+fi
+
+node -e '
+const mission = process.argv[1];
+const runtimeJson = process.argv[2];
+let payload;
+try {
+  payload = JSON.parse(runtimeJson);
+} catch {
+  process.stdout.write(JSON.stringify({ additional_context: "GXT: failed to parse runtime env" }));
+  process.exit(0);
+}
+const tmvc = (payload.GXT_TMVC_ROOTS || "").split("\n").filter(Boolean);
+const forbidden = (payload.GXT_FORBIDDEN_ZONES || "").split("\n").filter(Boolean);
+process.stdout.write(JSON.stringify({
+  env: payload,
+  additional_context: [
+    "GXT OpenGantry active mission (auto-loaded at session start):",
+    `- Mission: ${payload.GXT_MISSION_FILE || mission} (${payload.GXT_MSN_ID || "no MSN"})`,
+    `- Skill: ${payload.GXT_SKILL_KEY || "unknown"}`,
+    `- TMVC roots: ${tmvc.join(", ") || "(none)"}`,
+    `- Forbidden: ${forbidden.join(", ") || "(none)"}`,
+    `- Trace sink: ${payload.GXT_WORKER_LOG || "WORKER_LOG.md"}`,
+    "",
+    "Worker loop: edit within TMVC → append PASS quotes to WORKER_LOG.md → gapman verify --mission … → npm run validate",
+    "MCP tools: gxt_draft_legislation, gxt_execute_legislation, gxt_check_signature, gxt_pin_mission, gxt_runtime_env, gxt_verify (see .cursor/mcp.json).",
+    "IDE Agent edits are advisory TMVC; shell substrate writes are hook-guarded. Full loop: docs/DEVELOPMENT.md",
+  ].join("\n"),
+}));
+' "$MISSION" "$RUNTIME_JSON"
+
+exit 0

package/templates/.cursor/hooks.json

@@ -0,0 +1,15 @@
+{
+  "version": 1,
+  "hooks": {
+    "sessionStart": [
+      {
+        "command": ".cursor/hooks/gxt-session-start.sh"
+      }
+    ],
+    "beforeShellExecution": [
+      {
+        "command": ".cursor/hooks/gxt-before-shell.sh"
+      }
+    ]
+  }
+}

package/templates/.cursor/mcp.json

@@ -0,0 +1,8 @@
+{
+  "mcpServers": {
+    "opengantry-gxt": {
+      "command": "gapman",
+      "args": ["mcp", "serve"]
+    }
+  }
+}

package/templates/.cursor/rules/opengantry-gxt-substrate.mdc

@@ -0,0 +1,43 @@
+---
+description: OpenGantry GXT — read RULES and MANIFEST before any repo action
+alwaysApply: true
+---
+
+# OpenGantry substrate (mandatory read)
+
+## Activation Macro
+
+Whenever the user starts a prompt with `/gantry`:
+
+1. Immediately switch to Mission Architect behavior.
+2. Run the protocol in `.gitagent/teacher/MISSION-ARCHITECT.md`.
+3. Hand off via MCP tools (`gxt_draft_legislation` → chat approval → `gxt_execute_legislation`) or CLI `gapman legislate` fallback.
+
+Do not use `/plan` — Cursor reserves it for native Plan Mode.
+
+Before planning, editing code, or running substantive commands in this repository:
+
+1. Read **`.gitagent/teacher/RULES.md`** — governance (SOD, trace mapping, risk tiers, dynamic TMVC, Rule 4.4).
+2. Read **`.gitagent/foreman/MANIFEST.json`** — Foreman map (`schema_version`, per-skill `trust_threshold`, `tmvc_roots`, `forbidden_zones`, `path_risks`, `risk_keywords`).
+
+Treat these as the **law + routing contract** for agent work. For orientation and workflow, see **`.gitagent/README.md`**.
+
+## Mission Architect (IDE chat)
+
+**Implicit interception:** When the user **explicitly** asks to write, edit, refactor, or implement code and **no mission is pinned**, read **`.gitagent/teacher/MISSION-ARCHITECT.md`**.
+
+- **Do NOT** trigger for questions, explanations, or code discovery.
+- **MCP handoff:** two-step draft/execute with semantic chat approval before any mission file write.
+- **CLI fallback:** one copy-paste `gapman legislate …` command only (no raw YAML blocks).
+
+## Cursor wiring
+
+- **Rules:** this file (`alwaysApply: true`) + root `AGENTS.md`.
+- **MCP:** `.cursor/mcp.json` — `gxt_*` tools via `gapman mcp serve`.
+- **Hooks:** `.cursor/hooks.json` (installed by `gapman init`) — `sessionStart` mission scope + shell guard for GXT law/manifest paths (fallback for non-MCP shell paths).
+- **Pin mission:** `scripts/gxt-pin-mission.sh .gitagent/missions/<file>.yaml` before Agent work.
+- **Terminal bootstrap:** `source scripts/gxt-runtime-env.sh` (uses pinned mission or explicit path).
+- **Code architecture:** `.gitagent/ARCHITECTURE.pointer.json` — if `kind=unset` or stub, read `.gitagent/teacher/ARCHITECTURE-DISCOVERY.md` and ask user before coding.
+- **Human IDE setup:** `docs/INTEGRATIONS.md` (adopter reference — not agent context).
+
+If the user clearly scopes work to something that cannot affect OpenGantry (e.g. a typo in unrelated docs), still skim **RULES** and **MANIFEST** when the change could touch skills, missions, routing, or manifest sync.

package/templates/.gitagent/ARCHITECTURE.pointer.external.example.json

@@ -0,0 +1,13 @@
+{
+  "schema_version": "0.1.0",
+  "kind": "external",
+  "location": "https://wiki.example.com/display/ARCH",
+  "read_hint": "Fetch the ARCH space home page, then linked layer pages.",
+  "access": {
+    "required": true,
+    "tool": "confluence",
+    "credential_slot": "architecture/confluence",
+    "auth_hint": "Atlassian personal access token; API base URL is the location host.",
+    "detect": ["atlassian", "CONFLUENCE_", "mcp:atlassian"]
+  }
+}

package/templates/.gitagent/ARCHITECTURE.pointer.json

@@ -0,0 +1,9 @@
+{
+  "schema_version": "0.1.0",
+  "kind": "unset",
+  "location": "",
+  "read_hint": "Architecture source not selected. Do NOT invent layer layout or module boundaries. Read .gitagent/teacher/ARCHITECTURE-DISCOVERY.md and ask the user before any application code changes.",
+  "discovery": {
+    "skill": ".gitagent/teacher/ARCHITECTURE-DISCOVERY.md"
+  }
+}

package/templates/.gitagent/foreman/BYPASS.sha256

@@ -0,0 +1,2 @@
+# SHA-256 (hex) of the team GXT_BYPASS_SECRET. Replace this line with a 64-char hash only.
+# Example: echo -n 'your-secret' | sha256sum

package/templates/.gitagent/foreman/MANIFEST.json

@@ -0,0 +1,37 @@
+{
+  "schema_version": "0.5.0",
+  "skills": {
+    "ui": {
+      "desc": "UI components and styles within declared roots.",
+      "trust_threshold": "Tier-1",
+      "tmvc_roots": ["src/components/", "src/styles/"],
+      "forbidden_zones": [".gitagent/", "src/auth/", "src/core/", "src/db/schema/"]
+    },
+    "logic": {
+      "desc": "Application logic and utilities within declared roots.",
+      "trust_threshold": "Tier-2",
+      "tmvc_roots": ["src/lib/", "src/utils/"],
+      "forbidden_zones": [".gitagent/", "src/auth/", "src/core/", "src/db/schema/"]
+    },
+    "gapman": {
+      "desc": "gapman CLI delivery, lib layers, and unit tests (OpenGantry specimen).",
+      "trust_threshold": "Tier-2",
+      "tmvc_roots": ["src/cli/"],
+      "forbidden_zones": [".gitagent/foreman/", ".gitagent/teacher/RULES.md"]
+    },
+    "substrate": {
+      "desc": "Reserved for high-risk substrate work; requires Teacher mission.",
+      "trust_threshold": "Tier-3",
+      "tmvc_roots": [],
+      "forbidden_zones": []
+    }
+  },
+  "path_risks": {
+    "src/cli/": "Tier-2",
+    ".gitagent/": "Tier-3",
+    "src/core/": "Tier-3",
+    "src/auth/": "Tier-3",
+    "src/db/schema/": "Tier-3"
+  },
+  "risk_keywords": ["refactor", "migrate", "delete", "security", "schema"]
+}

package/templates/.gitagent/foreman/SUBSTRATE.version.json

@@ -0,0 +1,6 @@
+{
+  "schema_version": "0.1.0",
+  "opengantry_version": "1.0.0",
+  "installed_at": "2026-01-01T00:00:00.000Z",
+  "installed_by": "gapman init"
+}

package/templates/.gitagent/foreman/TEACHER.allowlist.example

@@ -0,0 +1,4 @@
+# One Git author email per line (case-insensitive). Committed team allowlist.
+# Personal override (gitignored): .gitagent/foreman/TEACHER.allowlist.local
+# Or: git config gapman.teacherEmails "you@example.com"
+teacher@example.com

package/templates/.gitagent/missions/README.md

@@ -0,0 +1,18 @@
+# Missions
+
+Store mission files here (`.md` or `.yaml`) for `gapman verify`.
+
+Quick start:
+
+1. Configure `.gitagent/foreman/MANIFEST.json` skill keys and roots.
+2. Set `GAPMAN_TEACHER_EMAILS`.
+3. Legislate with explicit id:
+
+```bash
+gapman legislate "<intent>" --msn MSN-0001 --skill-key <manifest-key> [--gate-command "<cmd>"]
+```
+
+Duplicate `msn_id` values fail closed by default; use `--allow-duplicate` only for intentional migration flows. New stubs emit `status: PENDING` trace rows until worker execution.
+
+For the full specimen runbook, see the upstream OpenGantry adoption guide:
+https://github.com/jeger-ai/opengantry/blob/main/docs/ADOPTION.md

package/templates/.gitagent/teacher/ARCHITECTURE-ACCESS.md

@@ -0,0 +1,85 @@
+# Architecture access (authenticated sources)
+
+Read this **before** fetching external architecture documentation when [`.gitagent/ARCHITECTURE.pointer.json`](../ARCHITECTURE.pointer.json) has `"access": { "required": true }`.
+
+## Goal
+
+Discover **which tool** hosts architecture docs, **how authentication works**, obtain credentials **without exposing secrets in chat or git**, then read layout docs and proceed under GXT rules.
+
+## 1. Read the pointer
+
+From the repo root, load `.gitagent/ARCHITECTURE.pointer.json`:
+
+- `kind`, `location`, `read_hint` — where docs live
+- `access.tool` — expected system (Confluence, Linear, Notion, custom MCP, …)
+- `access.detect` — signals to probe first (MCP server id, env prefix, host substring)
+- `access.auth_hint` — team-specific auth notes (PAT, OAuth, SSO, …)
+- `access.credential_slot` — local storage key (git-ignored)
+
+## 2. Detect existing access (do not ask yet)
+
+Check in order:
+
+1. **MCP / IDE integrations** — list configured MCP servers and tools; match `access.detect` and `access.tool`.
+2. **Environment** — env vars suggested by `access.detect` or `auth_hint` (never print values).
+3. **Stored credentials** — run `gapman arch cred status` (or `--slot <credential_slot>`). Status shows slot + kind only, never secrets.
+4. **User docs** — project README / human INTEGRATIONS doc for team setup (not duplicated here).
+
+If a path already works, record in `WORKER_LOG.md` which method you used (not the secret) and fetch architecture docs.
+
+## 3. Ask the user when detection fails
+
+Ask **one focused question at a time**:
+
+- Which system hosts architecture docs? (confirm or override `access.tool`)
+- How does your team authenticate? (PAT, API key, OAuth device flow, MCP already configured, …)
+- Whether you may store a credential locally via `gapman arch cred set` (git-ignored, mode 600)
+
+**Never** ask the user to paste tokens into chat, commits, or `WORKER_LOG.md`.
+
+## 4. Store credentials securely
+
+Use **`gapman arch cred set`** — secrets on **stdin only**, never argv:
+
+```bash
+# Bearer / PAT
+printf '%s' 'YOUR_TOKEN' | gapman arch cred set --slot architecture/confluence --kind bearer
+
+# API key
+printf '%s' 'YOUR_KEY' | gapman arch cred set --slot architecture/notion --kind api_key
+
+# Basic auth (JSON on stdin)
+printf '%s' '{"username":"you@corp.com","password":"…"}' | gapman arch cred set --slot architecture/wiki --kind basic
+```
+
+Files live under **`.gitagent/history/credentials/`** (git-ignored). Verify with `gapman arch cred status`.
+
+To remove: `gapman arch cred unset --slot <name>`.
+
+## 5. Context request (GXT)
+
+Before first access to an **external** architecture source, log a **Context Request** in `WORKER_LOG.md`: tool name, URL/host, auth method (not secrets), and why layout docs are needed. Wait for Verifier acceptance when tier/policy requires it.
+
+## 6. Read architecture docs
+
+Follow `read_hint` and consume layout boundaries. Align edits with `tmvc_roots` in MANIFEST.
+
+## Adopter configuration example
+
+In `ARCHITECTURE.pointer.json`:
+
+```json
+{
+  "schema_version": "0.1.0",
+  "kind": "external",
+  "location": "https://wiki.example.com/display/ARCH",
+  "read_hint": "Fetch space ARCH home, then layer pages linked from the index.",
+  "access": {
+    "required": true,
+    "tool": "confluence",
+    "credential_slot": "architecture/confluence",
+    "auth_hint": "Atlassian personal access token; base URL from location host.",
+    "detect": ["atlassian", "CONFLUENCE_", "mcp:atlassian"]
+  }
+}
+```

package/templates/.gitagent/teacher/ARCHITECTURE-DISCOVERY.md

@@ -0,0 +1,40 @@
+# Architecture discovery (unset or uncertain)
+
+Read this when [`.gitagent/ARCHITECTURE.pointer.json`](../ARCHITECTURE.pointer.json) has **`"kind": "unset"`**, or when pointed architecture docs are missing, empty, or still the init stub.
+
+## Hard rule
+
+**Do NOT define or assume the full codebase architecture yourself.** The user may expect you to invent layers, folders, and boundaries — that is the **worst outcome**. Uncertainty MUST be resolved with the user **before** planning or editing application code.
+
+## When this applies
+
+- Pointer `kind` is **`unset`** (no source selected)
+- `docs/ARCHITECTURE.md` (or pointed file) still contains placeholder text such as *"Replace this section with your project structure"*
+- Pointed directory is empty or has no layout guidance
+- External source is unreachable and no fallback docs exist in-repo
+
+## What to do (in order)
+
+1. **Stop** — do not scaffold modules, pick frameworks, or create folder trees based on guesses.
+2. **Tell the user** architecture is unset or incomplete and implementation will wait until layout is clarified.
+3. **Ask focused questions** (one or two at a time), for example:
+   - Where should architecture documentation live? (markdown file, folder, Confluence/wiki, other)
+   - What are the main layers or bounded contexts?
+   - Which directories are entry points for each skill / TMVC root in MANIFEST?
+   - Dependency direction rules (what may import what)?
+   - Existing conventions from another repo or ADR to follow?
+4. **Log a Context Request** in `WORKER_LOG.md` when the discussion expands scope beyond current TMVC.
+5. **Update the pointer** (or ask the user / Teacher to) once source is chosen — e.g. set `kind: file` and fill `docs/ARCHITECTURE.md`, or `kind: external` with `access` if authenticated.
+6. **Only then** proceed with implementation aligned to documented layout and MANIFEST `tmvc_roots`.
+
+## After the user answers
+
+- If they choose a **file** or **folder**, help them write concise architecture notes; update `.gitagent/ARCHITECTURE.pointer.json` accordingly.
+- If they choose **external**, set `kind: external`, follow [ARCHITECTURE-ACCESS.md](./ARCHITECTURE-ACCESS.md) for auth.
+- If they want **you to draft** architecture text, treat it as a **proposal** — present for explicit approval before treating it as law.
+
+## Never
+
+- Silently invent `src/` layout, clean/hexagonal layers, or package structure without approval
+- Treat generic best practices as this repository's architecture
+- Skip discovery because the task "sounds simple"

package/templates/.gitagent/teacher/MISSION-ARCHITECT.md

@@ -0,0 +1,93 @@
+# Mission Architect (Teacher-Assistant Contract)
+
+IDE chat protocol for drafting missions **before** worker execution. No CLI chatbot. No agent-authored Git commits.
+
+## When to activate
+
+**Activate when any of these are true:**
+
+1. User prompt **starts with** `/gantry` (explicit macro — planning-only prompts included). Do not use `/plan`; Cursor reserves it for native Plan Mode.
+2. User **explicitly** asks to write, edit, refactor, add, fix, or implement code (or equivalent action intent) **and** no pinned/legislated mission covers the work (`.gitagent/missions/.active-mission` absent or stale).
+
+**Do NOT activate for:**
+
+- Questions (“how does auth work?”, “explain this function”)
+- Read-only navigation, code discovery, or architecture exploration
+- Docs-only questions unless the user asks to edit docs
+- Casual conversation
+
+When inactive, answer normally — do not mention this protocol.
+
+## Phase 0 (silent reads)
+
+Before proposing legislation, read (do not lecture the user):
+
+- `.gitagent/foreman/MANIFEST.json` — skills, TMVC roots, forbidden zones, path_risks, risk_keywords
+- `.gitagent/ARCHITECTURE.pointer.json` — code layout (if `kind=unset`, follow ARCHITECTURE-DISCOVERY.md and ask)
+- Optional: `.gitagent/out-of-scope/` ADRs when scope is ambiguous
+
+**Do not** run `gapman triage` in chat. Reason from manifest + architecture directly.
+
+## Fast-path vs full interview
+
+### Fast-path (trivial work)
+
+Use when the change is trivial, low-risk, and clearly confined (e.g. single existing file, cosmetic tweak, obvious skill from manifest).
+
+1. Infer `skill_key`, `gate_command`, and MSN (ask for MSN only if unknown).
+2. Present legislation handoff (MCP tools preferred in Cursor — see below).
+3. Ask for **single yes/no** confirmation — no 3-phase interview.
+
+### Full 3-phase interview (heavy work)
+
+Use for new features, multi-file scope, forbidden-zone proximity, path_risks/risk_keywords hits, ambiguous skill, or when the user requests mission planning.
+
+| Phase | Focus |
+|-------|--------|
+| **1 — Boundary** | Skill, TMVC roots, forbidden zones |
+| **2 — Risk** | Concrete paths; escalation flags |
+| **3 — Verification** | Agree `gate_command` + success substring; DoD → future trace rows |
+
+## Handoff (legislate only)
+
+**Forbidden:** multi-line YAML mission blocks, “save this file manually” instructions, agent-authored Teacher git commits.
+
+### Cursor MCP (preferred — zero copy/paste)
+
+When the OpenGantry MCP server is configured (`.cursor/mcp.json`):
+
+1. Call **`gxt_draft_legislation`** with `title`, `msn_id`, `skill_key`, `gate_command`, optional `gate_success_substring`.
+2. Present the returned `chat_message_to_user` to the human.
+3. Wait for clear approval intent in chat (`yes`, `approve`, `looks good`, `do it`) or rejection (`no`, `deny`, `stop`). If ambiguous, ask one short clarification.
+4. On approval only, call **`gxt_execute_legislation`** with the `draft_token`.
+5. Render the returned `suggested_human_action` in a fenced shell block for the Teacher commit.
+6. After the human commits, call **`gxt_check_signature`**. On `signature_valid`, proceed to **`gxt_pin_mission`** then worker phase.
+
+This two-step draft/execute gate prevents silent legislation even when Cursor runs tools in auto-run (“Yolo”) mode.
+
+### CLI fallback (terminal)
+
+One bash command the user copies into their terminal:
+
+```bash
+gapman legislate "<intent summary>" --msn MSN-NNNN --skill-key <key> \
+  --gate-command "<deterministic gate shell command>" \
+  --gate-success-substring "<optional substring>"
+```
+
+- Quote `--gate-command` when it contains spaces.
+- Omit `--gate-success-substring` when exit code 0 alone is sufficient.
+
+**Stop after handoff.** Do not write application code until the Teacher commits and pins the mission.
+
+## Teacher loop (human)
+
+1. Approve draft (MCP) or paste and run `gapman legislate` (CLI).
+2. Optionally review/edit the generated YAML.
+3. `git commit -m "[MSN-NNNN] legislate …"` including the mission file (Teacher email in `GAPMAN_TEACHER_EMAILS`).
+4. Pin mission (`gxt_pin_mission` MCP tool or `scripts/gxt-pin-mission.sh`).
+5. Worker phase begins.
+
+## Worker phase (after pin)
+
+Edit within TMVC → append PASS quotes to `WORKER_LOG.md` → `gapman verify --mission …` (or `gxt_verify`) → pin stays until mission complete.

package/templates/.gitagent/teacher/MISSION.schema.yaml

@@ -0,0 +1,80 @@
+# MISSION.schema — JSON Schema (YAML encoding) for structured missions
+# Consumed by gapman (Ajv). Version label for docs only.
+$schema: https://json-schema.org/draft/2020-12/schema
+$id: https://opengantry.local/schemas/mission.v1_1.json
+title: OpenGantryMission
+type: object
+additionalProperties: false
+required:
+  - skill_key
+  - gate_command
+allOf:
+  - anyOf:
+      - required: [msn_id]
+      - required: [msnId]
+properties:
+  msn_id:
+    type: string
+    pattern: "^MSN-[0-9]{4}$"
+  msnId:
+    type: string
+    pattern: "^MSN-[0-9]{4}$"
+  skill_key:
+    type: string
+    minLength: 1
+  gate_command:
+    type: string
+    minLength: 1
+  gate_success_substring:
+    type: ["string", "null"]
+  upgrade_payload:
+    type: object
+    additionalProperties: false
+    required:
+      - from_version
+      - to_version
+      - staged_hashes
+      - planned_writes
+    properties:
+      from_version:
+        type: string
+      to_version:
+        type: string
+      staged_root:
+        type: string
+        const: ".gitagent/.upgrade-tmp"
+      planned_writes:
+        type: array
+        items:
+          type: string
+      skipped_scaffold_only:
+        type: array
+        items:
+          type: string
+      staged_hashes:
+        type: object
+        additionalProperties:
+          type: string
+      created_at:
+        type: string
+  trace_rows:
+    type: array
+    default: []
+    items:
+      type: object
+      additionalProperties: false
+      required:
+        - dod_id
+        - trace_quote
+        - anchor
+        - status
+      properties:
+        dod_id:
+          type: string
+        trace_quote:
+          type: string
+        anchor:
+          type: string
+        status:
+          type: string
+          pattern: "^(PASS|FAIL|PENDING|pass|fail|pending)$"

package/templates/.gitagent/teacher/RULES.md

@@ -0,0 +1,36 @@
+# OpenGantry Rules (template)
+
+Normative keywords **MUST**, **MUST NOT**, and **SHOULD** follow RFC 2119.
+
+## 1. Governance and risk tiers
+
+- **Tier 1 (SAFE)**: deterministic gate required; single-provider verifier is acceptable.
+- **Tier 2 (LOGIC)**: deterministic gate required; single-provider verifier output is advisory and a human audit is required before merge.
+- **Tier 3 (SUBSTRATE)**: strictest review path; human audit of trace-mapped evidence is mandatory.
+
+## 2. Segregation of duties
+
+- The agent executing the gate MUST NOT be the same actor declaring PASS.
+- Mission law is Teacher-owned; workers MUST NOT silently rewrite mission law.
+
+## 3. Trace-mapped verification
+
+- PASS claims MUST quote `WORKER_LOG.md` with a valid anchor (line or timestamp).
+- Missing quotes/anchors for claimed PASS is evidence tampering and MUST fail verification.
+
+## 4. Dynamic TMVC
+
+- Work is bounded to manifest roots unless explicit mission expansion is approved.
+- Access outside effective TMVC requires a context request recorded in `WORKER_LOG.md`.
+- Access into forbidden zones MUST fail closed unless Teacher policy explicitly allows it.
+
+## 5. Mission commit indexing
+
+- Mission-related commits MUST begin with `[MSN-XXXX]` in the subject line.
+- Keep mission files for `gapman verify` under `.gitagent/missions/`.
+
+## 6. Break-glass (v0.8.0)
+
+- Set `GXT_BYPASS_SECRET` to match `.gitagent/foreman/BYPASS.sha256` (SHA-256 hex of the team secret).
+- Use `gapman verify --break-glass --reason "..."` only in emergencies; push `refs/notes/gxt-bypass` with the branch.
+- Forbidden-zone runtime policy is never bypassed.

package/templates/.gitagent/teacher/WORKER_LOG.template.md

@@ -0,0 +1,2 @@
+# WORKER_LOG
+

package/templates/.githooks/post-checkout

@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+# post-checkout: create empty WORKER_LOG.md on branch checkouts (feature branches only).
+# Git passes: $1 = previous HEAD, $2 = new HEAD, $3 = 1 if branch checkout, 0 if file checkout.
+set -euo pipefail
+
+[[ "${3:-0}" == "1" ]] || exit 0
+
+cd "$(git rev-parse --show-toplevel)"
+
+# Detached HEAD — skip
+branch="$(git symbolic-ref -q --short HEAD 2>/dev/null)" || exit 0
+
+# Default branches — skip (edit if your primary branch differs)
+case "$branch" in
+  main|master) exit 0 ;;
+esac
+
+log_file="WORKER_LOG.md"
+[[ -f "$log_file" ]] && exit 0
+
+template=".gitagent/teacher/WORKER_LOG.template.md"
+if [[ -f "$template" ]]; then
+  cp "$template" "$log_file"
+else
+  printf '%s\n\n' '# WORKER_LOG' >"$log_file"
+fi

package/templates/.githooks/pre-push

@@ -0,0 +1,53 @@
+#!/usr/bin/env bash
+# OpenGantry pre-push: dogfood GXT — mission verify, manifest sync, changed CLI quality.
+set -euo pipefail
+
+cd "$(git rev-parse --show-toplevel)"
+
+if command -v gapman >/dev/null 2>&1; then
+  GAPMAN=(gapman)
+elif [[ -f dist/cli/index.js ]]; then
+  GAPMAN=(node dist/cli/index.js)
+else
+  echo "pre-push: gapman not found — run: npm run build" >&2
+  exit 1
+fi
+
+base="$(git merge-base HEAD @{upstream} 2>/dev/null || true)"
+if [[ -z "$base" ]]; then
+  base="$(git merge-base HEAD main 2>/dev/null || git merge-base HEAD master 2>/dev/null || true)"
+fi
+if [[ -z "$base" ]]; then
+  base="$(git rev-parse HEAD~1 2>/dev/null || true)"
+fi
+if [[ -z "$base" ]]; then
+  exit 0
+fi
+
+mapfile -t missions < <(
+  git diff --name-only --diff-filter=ACMRT "${base}..HEAD" -- .gitagent/missions/ \
+    | grep -E '\.(ya?ml|md)$' \
+    | grep -viE '(^|/)README\.md$' \
+    | sort
+)
+
+for mission in "${missions[@]}"; do
+  [[ -n "$mission" ]] || continue
+  [[ -f "$mission" ]] || continue
+  echo "pre-push: gapman verify --mission ${mission} (--pre-push)" >&2
+  "${GAPMAN[@]}" verify --mission "$mission" --pre-push || exit 1
+done
+
+if git diff --name-only "${base}..HEAD" | grep -qE '^\.gitagent/foreman/MANIFEST\.json$|^skills/'; then
+  echo "pre-push: gapman check (manifest / skills changed)" >&2
+  "${GAPMAN[@]}" check || exit 1
+fi
+
+if git diff --name-only "${base}..HEAD" -- 'src/cli/**/*.ts' | grep -q .; then
+  if [[ -x ./scripts/check-changed-code.sh ]]; then
+    echo "pre-push: changed-code quality (src/cli)" >&2
+    ./scripts/check-changed-code.sh "$base" HEAD || exit 1
+  fi
+fi
+
+exit 0