<!-- AUTO-GENERATED from SKILL.md.tmpl — do not edit directly --> <!-- Regenerate: bun run gen:skill-docs -->

Telemetry (run last)

After workflow completion, log telemetry with ONE command. OUTCOME is success/error/abort/unknown; SESSION_ID and TEL_START are the values the preamble's skill-start output echoed. It also drains the artifacts-sync queue (the former skill-end sync step — do not run gstack-brain-sync separately).

PLAN MODE EXCEPTION — ALWAYS RUN: This writes telemetry to $GSTACK_STATE_ROOT/analytics/, matching preamble analytics writes.

~/.claude/skills/gstack/bin/gstack-skill-end --skill "sync-gbrain" --outcome OUTCOME \
  --session-id "SESSION_ID" --tel-start "TEL_START" --used-browse USED_BROWSE \
  --error-message "ERROR_MESSAGE" --failed-step "FAILED_STEP" 2>/dev/null || true

Replace OUTCOME and USED_BROWSE (yes/no) before running; substitute SESSION_ID/TEL_START from the skill-start echoes. ERROR_MESSAGE/FAILED_STEP are "" unless outcome is error. If the command is missing (stale install), skip telemetry — it never blocks the workflow.

/sync-gbrain — Keep gbrain current and teach the agent to use it

You are running the canonical "keep this brain up to date" verb. /setup-gbrain installs gbrain once; /sync-gbrain runs every time the user wants the brain refreshed against this repo's current state, and refreshes the agent-side guidance in CLAUDE.md so the coding agent knows when to prefer gbrain search over Grep.

Architecture: This skill uses gbrain v0.20.0+'s native code surfaces (gbrain sources add, gbrain sync --strategy code, gbrain reindex-code, gbrain code-def/code-refs/code-callers/code-callees). It does NOT use gbrain import (that path is for markdown directories). It does NOT touch ~/.gstack/ indexing (the existing gstack-gbrain-source-wireup owns that — never double-store).

User-invocable

When the user types /sync-gbrain, run this skill. Argument modes (parsed by the skill itself, not a dispatcher binary):

• /sync-gbrain — incremental sync (default; mtime fast-path; ~50ms steady-state)
• /sync-gbrain --full — full code reindex via gbrain reindex-code (~25-35 min on a big repo). Auto-builds the call graph (gbrain dream --phase resolve_symbol_edges) only when it was never built.
• /sync-gbrain --dream — build this source's call graph (gbrain code-callers/code-callees) via gbrain dream --source <id> --phase resolve_symbol_edges; ~minutes; runs lock-free after the sync stages. Always forces, even if already built. Runs only that phase, never gbrain's full maintenance cycle (about 35 minutes with LLM phases); if the installed gbrain cannot scope the phase, the dream row says so and nothing runs. Only produces a graph on a code-aware schema pack; otherwise the run reports a WARN explaining why the graph is still empty.
• /sync-gbrain --no-dream — skip the dream cycle that --full would otherwise auto-run.
• /sync-gbrain --code-only — only run the code stage; skip memory + brain-sync
• /sync-gbrain --dry-run — preview what would sync; no writes anywhere
• /sync-gbrain --no-memory / --no-brain-sync — selectively skip stages
• /sync-gbrain --sources <types|all> — memory types to ingest (env GSTACK_MEMORY_INGEST_SOURCES); by default, types a federated gstack source already indexes are skipped, and transcripts are skipped unless transcript_ingest_mode is recent or all (a list naming transcript overrides that for one run)
• /sync-gbrain --quiet — suppress per-stage output
• /sync-gbrain --refresh-cache — force-rebuild brain-aware planning cache. Skips code + memory stages; routes to gstack-brain-cache refresh --project <slug>.
• /sync-gbrain --audit — emit summary of gstack-owned pages per project + sensitive-content audit. Read-only.

Pass-through args go straight to the orchestrator at ~/.claude/skills/gstack/bin/gstack-gbrain-sync.ts.

**--refresh-cache short-circuit:** when this flag is present, the skill runs ONLY the cache refresh (gstack-brain-cache refresh --project <slug> for the current worktree's slug, plus a cross-project refresh of user-profile if gstack/user-profile/<user-slug> exists). Code + memory + brain-sync stages are skipped. Useful when the user knows the brain has new info gstack should pick up before the next planning skill.

**--audit short-circuit:** when this flag is present, the skill runs gstack-brain-cache list --project <slug> --json, summarizes by page type, then scans for any cached salience entries that ended up outside the SALIENCE_DEFAULT_ALLOWLIST (leak check). Read-only; no modifications to brain or cache.

Step 1: State probe

Before doing anything, check that /setup-gbrain has been run on this machine.

~/.claude/skills/gstack/bin/gstack-gbrain-detect 2>/dev/null

Brain trust policy gate: If gbrain_mcp_mode == "remote-http" from the detect output AND the per- endpoint policy is unset, the policy question MUST fire here before the orchestrator runs. Local engines auto-set to personal silently per the per-transport default table.

_HASH=$(~/.claude/skills/gstack/bin/gstack-config endpoint-hash 2>/dev/null)
_POLICY=$(~/.claude/skills/gstack/bin/gstack-config get brain_trust_policy@$_HASH 2>/dev/null || echo unset)
echo "BRAIN_TRUST_POLICY[$_HASH]: $_POLICY"

If _POLICY == "unset" AND _HASH != "local", AskUserQuestion per the Step 9.5 wording in /setup-gbrain (personal vs shared, with persistence to brain_trust_policy@<hash> and conditional artifacts_sync_mode=full flip for personal). Then continue.

If _POLICY == "unset" AND _HASH == "local", auto-set personal:

~/.claude/skills/gstack/bin/gstack-config set brain_trust_policy@$_HASH personal

Split-engine model. Code stage runs locally against the per-machine gbrain engine (PGLite or whatever gbrain config points to), with each worktree of a repo registered as its own source. Memory stage also runs locally in local-stdio MCP mode — gstack-memory-ingest shells out to gbrain import against the same local engine. In remote-http MCP mode (Path 4), the memory stage instead persists staged markdown to ~/.gstack/transcripts/<run-id>/ and the artifacts pipeline pushes it to the brain admin's pull job. Brain-sync (the gstack-brain-sync push to git) is the one stage that never touches local engine and runs regardless of mode.

Practically: local PGLite stays code-only on remote-http machines; the remote brain holds everything else. Local-stdio machines mix code + transcripts in one local engine.

Also check the per-repo trust policy. If gstack-gbrain-repo-policy get for this repo returns deny, STOP:

"This repo's gbrain trust policy is deny. Run /setup-gbrain --repo to change it before syncing."

Step 1.5: Local engine pre-flight

Read gbrain_local_status from the Step 1 detect output. Branch as follows BEFORE invoking the orchestrator:

• **ok**: proceed to Step 2 normally.
• **timeout**: proceed to Step 2 — the engine is most likely healthy but slow (cold pooler connection). Tell the user in one line: "Engine probe timed out (>15s) — proceeding; raise GSTACK_GBRAIN_PROBE_TIMEOUT_MS if your pooler is slow." Do NOT treat this as a broken config.
• **thin-client**: proceed to Step 2 — this machine is a thin client of a remote-HTTP MCP brain: no local engine BY DESIGN, so the code, memory, and dream stages will SKIP with a thin-client reason (code indexing runs on the brain server; memory syncs via the remote brain's artifacts pull). Only the brain-sync push runs locally. Tell the user in one line: "Thin client of a remote brain — local stages skip by design; brain queries work via remote MCP (reachability is verified at use time, not probed here)." Do NOT route this into the broken-config remediation.
• **engine-locked**: STOP. "The local PGLite database is busy, usually because gbrain serve from a live Claude session owns it. Stop that process or run /sync-gbrain outside the live session, then retry. This identifies the conflict but does not remove PGLite's single-process limit."
• **no-cli**: STOP. "Local gbrain CLI not installed. Run /setup-gbrain first."
• **missing-config** AND gbrain_mcp_mode == "remote-http": tell the user "Your brain queries (the mcp__gbrain__* tools) work via remote MCP, but symbol code search needs a local PGLite. Run /setup-gbrain and pick 'Yes' at the local code-search prompt (Path 4, step 4d), or run gbrain init --pglite --json --embedding-model voyage:voyage-code-3 --embedding-dimensions 1024 directly (drop the voyage flags if VOYAGE_API_KEY isn't set). Continuing without code stage." Then proceed to Step 2 — the orchestrator's runCodeImport() and runMemoryIngest() will return SKIP; only runBrainSyncPush() will run. Do NOT abort.
• **missing-config** AND gbrain_mcp_mode != "remote-http": STOP. "Local gbrain CLI is installed but no engine config. Run /setup-gbrain first."
• **db-unreachable**: STOP. Print gbrain_local_status_detail from the detect JSON verbatim (for example "database host unreachable (ENOTFOUND db.example.com); your gbrain config is unchanged. Fix: check network or VPN, then re-run /sync-gbrain."). Never suggest moving the config aside.
• **broken-config OR broken-db**: STOP with a clear message: ``` Local gbrain config at ~/.gbrain/config.json points at an unreachable engine (status: {gbrain_local_status}). Two options:
• Re-run /setup-gbrain — Step 1.5 offers Retry / Switch to PGLite / Switch brain mode / Quit.
• Repair manually: mv ~/.gbrain/config.json ~/.gbrain/config.json.bak && gbrain init --pglite --json --embedding-model voyage:voyage-code-3 \ --embedding-dimensions 1024 (drop voyage flags if VOYAGE_API_KEY unset) Re-run /sync-gbrain after. ``` Do NOT continue — the orchestrator would skip code+memory and only run brain-sync, which is a degraded state the user should fix explicitly.

This pre-flight short-circuits the orchestrator before it spends ~80ms probing the engine again. The orchestrator independently runs the same classifier for defense-in-depth, but Step 1.5's STOP is where the user gets the actionable remediation message.

Step 1.6: Transcript consent

Claude Code and Codex session transcripts are ingested only when transcript_ingest_mode is recent (last 90 days), all (all history) or new@<UTC time> (only sessions that start after it), optionally narrowed to the repos in transcript_repos (the value then ends in +repos). Skip this step for --code-only, --no-memory, --dry-run, --refresh-cache and --audit. Otherwise check whether the user chose; has tells an absent key from the off default that get prints:

_TIM=$(~/.claude/skills/gstack/bin/gstack-config get transcript_ingest_mode 2>/dev/null || true)
if ~/.claude/skills/gstack/bin/gstack-config has transcript_ingest_mode; then
  _T='[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]t[0-9][0-9]:[0-9][0-9]:[0-9][0-9]z'
  case "$(printf '%s' "$_TIM" | tr -d '[:space:]' | tr '[:upper:]' '[:lower:]')" in
    recent|all|off|recent+repos|all+repos|new@$_T|new@$_T+repos)
      echo "TRANSCRIPT_MODE: $_TIM (repos: $(~/.claude/skills/gstack/bin/gstack-config get transcript_repos 2>/dev/null || true))" ;;
    *) echo "TRANSCRIPT_MODE: ask (stored value '$_TIM' is not recognized by this version)" ;;
  esac
else
  echo "TRANSCRIPT_MODE: ask (not set)"
fi

A stored value (recent, all, off, new@<time>, any with +repos): continue to Step 2 without asking. On ask, with SESSION_KIND: spawned or headless, do not ask and store nothing: the sync skips transcripts and prints how to choose. In an interactive session, ask once. Count first (--sources transcript counts sessions that are not consented yet):

bun --no-env-file --config=/dev/null run ~/.claude/skills/gstack/bin/gstack-memory-ingest.ts --probe --sources transcript
bun --no-env-file --config=/dev/null run ~/.claude/skills/gstack/bin/gstack-memory-ingest.ts --probe --sources transcript --all-history

If both report Total files in window: 0, ask yes/no: "Ingest coding-agent sessions as they appear?" Yes means recent, No stores off. Otherwise AskUserQuestion: name both sources (Claude Code and Codex sessions from every project on this machine that repo policy allows), the counts from the two probes, and the destination: the local brain (gbrain_engine from Step 1: PGLite or Supabase) or, in remote-http mode, the artifacts repo the remote brain pulls from. Say that a full sync of a large history can take a while and skills stay usable meanwhile. Options:

• A) Yes, last 90 days (recent)
• B) Yes, all history (all)
• C) Yes, only new sessions starting now (new)
• E) No, never ingest transcripts (off)

On any yes (the yes/no form included), ask a second, separate question: "Which repos' sessions?" A) every project repo your repo policy allows, or B) only this repo (offer B only when git remote get-url origin succeeds). Store nothing until both answers are known; a cancel in between stores nothing. Then store the scope, then the value (never the letter; new stores new@ plus the current UTC time), and continue to Step 2:

~/.claude/skills/gstack/bin/gstack-config set transcript_repos "$(git remote get-url origin)"  # only this repo
~/.claude/skills/gstack/bin/gstack-config unset transcript_repos                                 # every repo
~/.claude/skills/gstack/bin/gstack-config set transcript_ingest_mode <recent|all|off|new@$(date -u +%Y-%m-%dT%H:%M:%SZ)>

The sync prints what it will ingest, in words; repeat that line to the user.

Other memory types sync whatever the answer. Details: setup-gbrain/memory.md#transcripts.

Step 2: Run the orchestrator

Pass the user's flags to the orchestrator as <user-args>, unchanged (empty for a plain run). Use them only when every word is one of --incremental, --full, --dry-run, --quiet, --no-code, --no-memory, --no-brain-sync, --code-only, --dream, --no-dream, --allow-reclone, --prune-gone-worktrees, or --sources followed by one comma-separated list of lowercase memory types (or all). Any other value is not used: do not run the command; tell the user which value was rejected.

bun --no-env-file --config=/dev/null run ~/.claude/skills/gstack/bin/gstack-gbrain-sync.ts <user-args>

The orchestrator runs three stages: code → memory → brain-sync. Each stage failure is non-fatal; subsequent stages still run. State is persisted to ~/.gstack/.gbrain-sync-state.json via tmp-file + atomic rename. Concurrent runs are blocked by a lock file at ~/.gstack/.sync-gbrain.lock (5-min stale-takeover).

Step 3: Code-index health check

After the sync run, verify the cwd source registration and its page count:

SOURCE_JSON=$(bun --no-env-file --config=/dev/null run ~/.claude/skills/gstack/bin/gstack-gbrain-read-capability.ts --source-only 2>/dev/null)
SOURCE_ID=$(printf '%s' "$SOURCE_JSON" | jq -er 'if .status=="source" then .source_id else empty end' 2>/dev/null)
PAGES=$(printf '%s' "$SOURCE_JSON" | jq -er 'if .status=="source" and (.page_count | type)=="number" then .page_count else empty end' 2>/dev/null)
echo "cwd source: $SOURCE_ID, page_count: $PAGES"

--source-only validates the pretty state schema, writer, successful code stage, real worktree path, .gbrain-source pin, and gbrain's registration path before returning its safe integer page count. It does not read any page. An empty source or page count is unknown, not zero: report WARN and do not offer a full reindex on that evidence. If PAGES is proven 0 AND the user did NOT pass --no-code AND mode was not --full, AskUserQuestion via the format in the preamble:

D1 — This repo has 0 indexed pages in gbrain. Run a full code reindex now? ELI10: gbrain hasn't indexed this repo's code yet. The semantic search tools (gbrain search, code-def, code-refs) will return nothing until we run a full pass. Takes ~25-35 minutes on a big repo. Recommendation: A — the brain is unusable for code search until indexed, and Step 2 of this skill already verified gbrain is configured correctly. Note: options differ in kind, not coverage — no completeness score. A) Run /sync-gbrain --full now (recommended) B) Skip — I'll run it later

If A: re-invoke the orchestrator with --full --code-only. If B: continue to Step 4 with the empty-corpus state recorded.

Step 3.5: Call-graph health check (offer --dream)

gbrain code-callers / code-callees (who-calls-this / what-this-calls) return count: 0 until a gbrain dream cycle runs the resolve_symbol_edges phase for this source — not done by the code import in Step 2.

One hard prerequisite: building a call graph requires this source's active schema pack to extract code symbols (the extract_atoms phase). On a pack that doesn't declare it (e.g. gbrain-base / gbrain-base-v2), a dream cycle completes but resolve_symbol_edges matches nothing — the graph stays empty no matter how many times you run it. So "build the call graph" is only meaningful on a code-aware pack. The --dream stage detects this and reports it honestly (a WARN row) rather than claiming a build that didn't happen. code-def / code-refs need the same symbol extraction; they are NOT free "direct lookups" on a non-code-aware pack.

A source can also hold no code pages at all while reporting a healthy page count (a source added outside gstack syncs with gbrain's default markdown strategy). On gbrain 0.60 or later, code-def for a symbol that cannot exist answers .status: ready (the source holds code), out_of_scope (it holds none, so --dream cannot help), or nothing usable on older gbrain or an error.

Detect whether this source's call graph is built via doctor's cycle_freshness check, matching the cwd SOURCE_ID literally. doctor --fast skips the DB checks that carry it, so this reads --scope=brain (DB checks, no skill walk):

SOURCE_JSON=$(bun --no-env-file --config=/dev/null run ~/.claude/skills/gstack/bin/gstack-gbrain-read-capability.ts --source-only 2>/dev/null)
SOURCE_ID=$(printf '%s' "$SOURCE_JSON" | jq -er 'if .status=="source" then .source_id else empty end' 2>/dev/null)
CYCLE=unknown
CYCLE_WHY=""
if [ -n "$SOURCE_ID" ]; then
  # doctor exits 1 when any check fails; its JSON report is still complete.
  CYCLE=$(gbrain doctor --json --scope=brain 2>/dev/null \
    | jq -er --arg id "$SOURCE_ID" '
        if type!="object" or has("error") then "unknown"
        else ([.checks[]? | select(.name=="cycle_freshness")][0]) as $c
          | if $c == null then "unexposed"
            elif $c.status=="ok" then "completed"
            else ((($c.message // "") / "; ") | map(select(index("\u0027" + $id + "\u0027"))) | .[0] // "") as $i
              | if ($i | index("never completed")) then "never"
                elif ($i | index("last cycled")) then "completed"
                else "unknown" end end end' 2>/dev/null || echo unknown)
  if [ "$CYCLE" = unexposed ]; then CYCLE=unknown; CYCLE_WHY="installed gbrain does not expose cycle_freshness"; fi
fi
# index() = literal substring (NOT test() regex), matching the lib reader in
# readCycleStatus(). A fail/warn that doesn't name this source → "unknown"
# (don't mask other-source failures).
echo "call graph for $SOURCE_ID: $CYCLE${CYCLE_WHY:+: $CYCLE_WHY}"
CODE_SCOPE=unknown
if [ -n "$SOURCE_ID" ]; then
  CODE_SCOPE=$(gbrain code-def ZzzGstackProbeSymbolThatCannotExist --source "$SOURCE_ID" --limit 1 2>/dev/null \
    | sed -n '/^[[:space:]]*{/,$p' | jq -r '.status // "unknown"' 2>/dev/null || echo unknown)
  case "$CODE_SCOPE" in ready|out_of_scope) ;; *) CODE_SCOPE=unknown ;; esac
fi
echo "code scope for $SOURCE_ID: $CODE_SCOPE"

If CODE_SCOPE == out_of_scope, do not offer a build: report "this source holds no code pages (it syncs with gbrain's markdown strategy), so a call-graph build cannot help; re-sync it with gbrain sync --strategy code --source <id> to index its code" and continue to Step 4.

If CYCLE == never AND CODE_SCOPE is ready or unknown AND the user did NOT pass --dream/--full AND Step 3 PAGES > 0, AskUserQuestion via the format in the preamble:

D2 — This repo's call graph isn't built. Build it now? ELI10: gbrain code-callers/code-callees (who calls this function / what it calls) return nothing until the resolve_symbol_edges phase runs for this source. gbrain dream --source <this source> --phase resolve_symbol_edges runs only that phase (scoped to this worktree's code, takes a few minutes, not the full ~35-minute maintenance cycle). It only produces a graph if this source's schema pack extracts code symbols; if it doesn't, the run completes but the graph stays empty and the dream row will say so. Recommendation: A — call-graph queries return 0 until this runs, and the code index is already populated. If A comes back as a WARN ("pack does not extract code symbols"), the fix is a code-aware schema pack, not re-running dream. Note: options differ in kind, not coverage — no completeness score. A) Run /sync-gbrain --dream now (recommended) B) Skip — I'll run it later

If A: re-invoke the orchestrator with --dream --code-only (skips memory + brain-sync; the dream stage still runs because it's gated on --dream). Then report the dream stage's ACTUAL row — OK call graph built (N edges) vs a WARN that names why the graph is still empty (non-code-aware pack, missing embedding key, or 0 edges matched). Do not claim success on a WARN. If B: continue to Step 4 with the call-graph-not-built state recorded for the verdict.

If CYCLE == completed or unknown, do not prompt — but note completed means only that a cycle has run, not that edges exist (a non-code-aware pack reports completed with an empty graph). Step 5's verdict row surfaces the real state.

Step 4: Refresh ## GBrain Search Guidance block in CLAUDE.md

Capability check:

bun --no-env-file --config=/dev/null run ~/.claude/skills/gstack/bin/gstack-gbrain-read-capability.ts <user-args>

<user-args> are the same checked flags this /sync-gbrain invocation passed to Step 2, unchanged (empty for a plain run). The helper needs no other input: run it once and use its JSON result; do not inspect its source or the gbrain CLI first.

The helper reports JSON status: ready only after the successful code sync's source and real worktree match .gbrain-source, the source registration points to that worktree, and a bounded, source-scoped list/get returns the same page. It never creates or deletes a page. A get may update gbrain's internal retrieval metadata; the guarantee is no page or source mutation, not zero internal writes. status: unknown (including transient CLI errors, stale state, or an unverified response) is NOT evidence that the brain is unusable. A status: skipped result for --no-code, --dry-run, --refresh-cache, or --audit means no code-read probe was attempted. Do not run a write probe, switch to another source, or claim a successful read.

Then update CLAUDE.md based on the helper's status:

**If status=ready** — write or update the block. Idempotent: find the HTML-comment-delimited block; replace its body if it exists; append at the end of CLAUDE.md if it doesn't. NEVER duplicate. Block is machine-AGNOSTIC (no engine, no page counts, no last-sync time — those are in the existing ## GBrain Configuration block).

Verbatim block content (copy exactly):

## GBrain Search Guidance (configured by /sync-gbrain)
<!-- gstack-gbrain-search-guidance:start -->

This worktree's pinned code source answered a source-scoped page read. This
does not verify semantic search or write availability. Prefer gbrain over Grep
when the question is semantic or when you don't know the exact identifier yet;
if a query fails, report that failure rather than assuming the index is healthy.

**This worktree is pinned to a worktree-scoped code source** via the
`.gbrain-source` file in the repo root (kubectl-style context).
`gbrain code-def`, `code-refs`, `code-callers`, `code-callees`, `search`, and
`query` from anywhere under this worktree route to that source by default —
no `--source` flag needed (gbrain >= 0.41.38.0; on older gbrain the call-graph
commands need `--source "$(cat .gbrain-source)"`). Conductor sibling worktrees
of the same repo each have their own pin and their own indexed pages, so
semantic results match the code on disk here.

Call-graph queries (`code-callers`/`code-callees`) also need the graph to be
built first. A `count: 0` has several causes, and only one is fixed by
`/sync-gbrain --dream` (or `--full`): the graph was never built. Check the others
first: the source may hold no code at all (`gbrain code-def <any-symbol>
--source <id>` answers `status: out_of_scope`), the symbol may be dotted (these
verbs take a bare name), or `--all-sources` was used. `--dream` also needs a
schema pack that extracts code symbols; on another pack it completes, the graph
stays empty and it reports a WARN. `code-def`/`code-refs` need the same
extraction.

Two indexed corpora available via the `gbrain` CLI:
- This worktree's code (auto-pinned via `.gbrain-source`).
- `~/.gstack/` curated memory (registered as `gstack-brain-<user>` source via
  the existing federation pipeline).

Prefer gbrain when:
- "Where is X handled?" / semantic intent, no exact string yet:
    `gbrain search "<terms>"` or `gbrain query "<question>"`
- "Where is symbol Y defined?" / symbol-based code questions:
    `gbrain code-def <symbol>` or `gbrain code-refs <symbol>`
- "What calls Y?" / "What does Y depend on?":
    `gbrain code-callers <symbol>` / `gbrain code-callees <symbol>`
- "What did we decide last time?" / past plans, retros, learnings:
    `gbrain search "<terms>" --source gstack-brain-<user>`

Grep is still right for known exact strings, regex, multiline patterns, and
file globs. Run `/sync-gbrain` after meaningful code changes; for ongoing
auto-sync across all worktrees, run `gbrain autopilot --install` once per
machine — gbrain's daemon handles incremental refresh on a schedule.

Safety: don't run `/sync-gbrain` while `gbrain autopilot` is active — the
orchestrator refuses destructive source ops when it detects a running autopilot
to avoid racing it. Prefer registering user repos with `gbrain sources
add --path <dir>` (no `--url`): URL-managed sources can auto-reclone, and the
sync code walk for them requires an explicit `--allow-reclone` opt-in.

<!-- gstack-gbrain-search-guidance:end -->

Read CLAUDE.md once and compute its new content. The replacement target is the entire region from <!-- gstack-gbrain-search-guidance:start --> through <!-- gstack-gbrain-search-guidance:end -->. If those markers are missing, search for ## GBrain Search Guidance (configured by /sync-gbrain) heading and replace from there to the next ## or EOF. If no heading exists, append the entire block at the end of CLAUDE.md.

Atomic write (the only write path; do not Edit CLAUDE.md in place): Write the complete new content to CLAUDE.md.sync-gbrain.tmp beside it, then mv it over CLAUDE.md, so a crash mid-write never leaves the file half-modified. Verify the block count in the same Bash call as the mv, then go to Step 5.

**If status=unknown** — preserve the existing guidance block, if any, and report the helper's reason as WARN with advice to retry /sync-gbrain or the read check when the transient failure clears. Do not install new guidance on an unknown result or remove the existing guidance merely because this read could not verify it. The ## GBrain Configuration block stays in place.

**If status=skipped** — leave guidance unchanged. Report that code readiness was not probed in this mode, not that it passed or failed.

Do NOT crash if CLAUDE.md is missing or unwritable — log a warning and continue.

Step 5: Verdict block (idempotent doctor output)

Print a status block matching /setup-gbrain Step 10 conventions. Each row is [OK]/[FIX]/[WARN]/[ERR]. Reuse gbrain doctor --json --fast for informational rows but DO NOT gate the guidance block on doctor (doctor fails for reasons unrelated to code search).

gbrain status: GREEN

  CLI ............. OK   <gbrain version>
  Engine .......... OK   <pglite|supabase>
  Capability ...... OK   source-scoped page read verified (no page/source mutation)
  CWD source ...... OK   <gstack-code-{repo_slug}> (page_count=<N>)
  Call graph ...... OK   <N> edges resolved (code-callers/callees live)
  ~/.gstack source. OK   <gstack-brain-{user}> (page_count=<N>) — managed by /setup-gbrain
  Memory sync ..... OK   <artifacts_sync_mode>
  Transcripts ..... OK   <recent|all> | INFO <off|not set>: skipped
  CLAUDE.md ....... OK   ## GBrain Search Guidance present
  Last sync ....... OK   <last_sync from state file>

Run `/sync-gbrain` again any time gbrain feels off; safe and idempotent.

The Call graph row reports the most authoritative signal available:

1. If a dream stage ran this invocation (--dream, or --full auto-build), mirror its row verbatim — it's the ground truth for this run:
2. OK <N> edges resolved (code-callers/callees live)
3. WARN dream ran but this source's schema pack does not extract code symbols — switch to a code-aware pack (\gbrain schema use <pack>\)
4. WARN dream ran but the embed phase failed (missing embedding key)
5. WARN dream ran but resolved 0 edges (no code symbols matched yet)
6. Otherwise fall back to the CYCLE value from Step 3.5, with honest wording (a completed cycle proves a cycle ran, NOT that edges exist):
7. completed → OK cycle complete — code-callers/callees live IF this source's pack extracts code symbols
8. never → WARN call graph not built — run /sync-gbrain --dream
9. unknown → WARN could not probe call graph (doctor unavailable) — run /sync-gbrain --dream if code-callers returns 0

Any WARN Call graph row flips the verdict to YELLOW.

If any row is YELLOW or RED, the verdict line says so and the failing rows surface a one-line next action. An unknown read gives Capability ...... WARN source-scoped read unverified; guidance preserved — retry /sync-gbrain and flips the verdict to YELLOW, not RED. For a skipped probe, show Capability ...... WARN code read not probed in this mode; guidance unchanged and do not print a GREEN capability verdict. A never/unknown Call graph row flips the verdict to YELLOW.

Concurrency note

This skill is safe to run concurrently from multiple terminals on the same machine. The orchestrator acquires a lock at ~/.gstack/.sync-gbrain.lock before any state-file or CLAUDE.md mutation and exits with code 2 if another sync is in flight. Stale locks (process died) auto-clear after 5 minutes.

Cross-machine note

The ## GBrain Search Guidance block is committed to the repo's CLAUDE.md and travels with git push/git pull — NOT through ~/.gstack/.brain-allowlist (which is for ~/.gstack/ brain-sync only). On a different machine with a synced CLAUDE.md but no local gbrain, /sync-gbrain reports an unknown read and preserves the block rather than deleting committed instructions based on a transient or machine-local failure. Agents must not treat unknown as ready.

Status reporting

End with a Completion Status (per the preamble protocol):

• DONE — all stages green, CLAUDE.md guidance block present, verdict GREEN.
• DONE_WITH_CONCERNS — sync ran but at least one stage failed or capability read was unverified. List which and preserve retry guidance.
• BLOCKED — could not acquire lock, gbrain not on PATH, or per-repo policy is deny. State the blocker.
• NEEDS_CONTEXT — /setup-gbrain has not been run, or gbrain doctor shows a state that requires user decision (e.g., engine migration).