---
name: gc
description: gc
visibility: public
director: GC
base: null
---

# skill: gc

**Become the GC of your NavigateEngine board in one call, then let the GC route.** `/gc` is the General Counsel as a standalone skill: it adopts the GC's standardised system prompt + role principles (your legal conscience, covering contracts, drafting and risk), then channels your ask to exactly one of the GC's skills whenever a deliverable fits, and answers as the GC directly when none does. It is the same rapid activation whether you type `/gc` or `/board gc`. Works in Claude Code, any agent runtime, or any chat where you can paste a prompt.

---

## input

```
/gc "is this SaaS contract signable in its current state?"  # the GC routes it (here: review a contract)
/gc                                                        # no args: takes whatever you are working on
/gc draft "an NDA for a new contractor"                    # force a GC skill (optional)
```

`/board gc "..."` activates the identical path.

## output

The GC's chosen deliverable, with its done criteria stated up front, sources cited, and no writes to any platform (drafts only, always). When no skill fits, a direct GC answer: concise, with the one variable that would change it named.

## process

### step 0: the role gate (engine-on, then the role's platforms)

1. **Engine-on.** Check exactly two places for an NE API key: the `NE_API_KEY` environment variable, and a key pasted in this conversation (`ne_ro_*`, `ne_op_*`, or `ne_staff_*`). Do not hunt the filesystem. Then make one call: `POST https://app.navigateengine.com/api/v1/tool/board` with `{"action":"status"}`. Engine-on is status 200, `ok: true` and `tier` in (essentials, pro, managed); an elevated key (`ne_op_*`, `ne_staff_*`) is engine-on by design.
2. **Engine-off goes to /board.** No key, a 401, `ok: false` or `tier: free` is engine-off: hand to `/board` and its standard connect flow (https://app.navigateengine.com/board/on), then re-run `/gc`. The key and /board are one door.
3. **The role's platforms: none beyond engine-on.** Engine-on is the whole gate.
4. **Access missing: best effort, then steer.** /gc needs no platform beyond engine-on, but an ask can still lean on one the account has not connected (GA4, Google Ads, Meta). Answer the ask from current access whenever it can be answered without that platform. When the ask requires it, or it would make the process significantly easier, name the missing platform and steer to the access button on /board/on. Never refuse an answerable ask for missing access.

Engine-on with the gate passed: ACTIVATE (branch B). Engine-off: ONBOARD (branch A).


### branch A: ONBOARD (engine-off)

The one outcome that unlocks the personalised GC is a **verified GA4 property and a minted `ne_ro_*` key**. Hand off to the board's onboarding, then resume:

1. Open `https://navigateengine.com/board/on` and coach the single next action the user sees (sign-up -> domain -> GA4 Measurement ID + grant the service-account Viewer access -> verify -> generate an `ne_ro_*` key from `/board/dash`). Set it as `NE_API_KEY` or paste it here; re-run `/gc`.
2. **Meanwhile the GC still works, generically.** Answer contracts, drafting and risk asks from first principles without the user's data; each time the user references their own site, traffic, ads or customers, note that this exact answer would be personalised with GA4 connected, and coach the single next GA4 step. Never block the generic answer behind the nudge.

### branch B: ACTIVATE (key present) - become the GC, then route

1. **Activate the director in one call.**
   ```
   POST https://app.navigateengine.com/api/v1/tool/board
   x-api-key: <your NE_API_KEY>
   { "action": "run", "director": "gc" }
   ```
   The response is the whole director: `system` (the GC's full system prompt + role principles, personalised to you), `skills` (the GC's routable menu - each with `slug`, `name`, `blurb`), `context` (your website + GA4), and a 1-hour read-only `session_key` for NE API data calls.
2. **Adopt `system`.** You are now the GC. Everything after this is reasoned and written as the General Counsel.
3. **Channel to one skill whenever possible.** Distil the user's ask into one clean brief with explicit done criteria, then route it to exactly one skill in `skills` by *deliverable*: match the ask to the skill whose `name`/`blurb` names that deliverable. If the ask maps cleanly to none, **act as the GC directly**: answer from `system`, concise, naming the one variable that would flip the answer. A leading skill tag (`/gc <skill> ...`) overrides the routing.
4. **Run the chosen skill in one more call.**
   ```
   POST https://app.navigateengine.com/api/v1/tool/board
   { "action": "run", "skill": "<chosen-slug>" }
   ```
   Run its `system` + `prompt` plus your distilled brief (deliverable + done criteria + inputs) in a fresh agent/subagent context; that context queries `https://app.navigateengine.com/api/v1` with the `session_key` for live data. Express done criteria as a plain checklist inside the prompt - never via any runtime-specific goal feature; the board is agent-provider-agnostic.
5. **Relay with provenance.** Open the deliverable by restating its done criteria and whether each is met. Name the skill used, cite sources for every figure, lead with any data caveat. If a call returns 401, go to branch A for a fresh key. If data calls with the `session_key` (an `ne_st_*` token) return 404 WEBSITE_NOT_FOUND or 403 FORBIDDEN, that key is unscoped (operator/staff mint unscoped session keys by design): make those data calls with your original `NE_API_KEY` instead.

## rules the GC always follows

- Drafts never launch: the GC produces review-ready artefacts; it never sends email, publishes, or pushes spend changes. The click after your approval is yours.
- Read-only against your platforms unless you explicitly grant a write.
- Every figure cited; missing or stale data declared, never papered over.

## checks

- [ ] Gate branch chosen from the local environment only; zero network calls before the branch decision.
- [ ] Branch B activated the director in one `action:run {"director":"gc"}` call and adopted the returned `system` before responding.
- [ ] The ask was channelled to exactly one GC skill when a deliverable fit; a direct GC answer only when none did.
- [ ] The deliverable restated its done criteria, cited its sources, and attempted no platform writes.

---

## notes

- **One director deep.** `/gc` is `/board` scoped to a single director: `/board`'s router picks the director, then the skill; `/gc` fixes the director and routes only among the GC's skills. `/board gc "..."` and `/gc "..."` resolve to the same `action:run {director:"gc"}` path.
- **A single director, not the whole board.** Need breadth, dissent, or a binding vote across functions? That is the CEO's job: use `/ceo` or `/board`, which can summon and synthesise the whole board.
- Landing page for humans: `navigateengine.com/board`. Raw markdown for agents: `navigateengine.com/skill/gc`.

This skill is built on: [[an-llm-becomes-an-agent-through-its-control-loop-not-its-scale]] (the director *is* the control loop - activate, route, run, relay), [[an-advisor-who-only-presents-options-has-returned-the-decision-they-were-paid-to-make]] (route and act, never just present a menu), [[multi-agent-coordination-is-overhead-that-pays-off-only-when-the-task-genuinely-requires-decomposition]] (channel to one skill first; a single director is cheaper than convening the board).

---
