Runtime tactical context hydration — staged discovery and bounded source-bearing hydration for agent intent. Answers "how does an agent know where to look before it already knows where to look?" via filesystem shape, structural signals, and typed candidate baskets. Working acronym: RTCH (runtime-tactical-context-hydration).
CENTROID:
intent → bounded, source-reenterable evidence packet via staged source-bearing discovery
IS:
- structured intake of agent/Architect intent (goal, seeds, profile, fanout, mutation risk)
- zone orientation (cwd / repo root / zone root / rung chain / obvious truth files)
- low-cost shape scout (directory map, headings, durable handles, JSON/YAML keys, refs)
- typed candidate basket with origin/use taxonomy and pairing rule enforcement
- tactical probe plan (multiple bounded probes, not one giant regex)
- bounded chunk hydration with line-range provenance and next-re-entry commands
- agent-ready evidence packet emission (selected_surfaces, unresolved_questions, caution_map)
- optional handoff to /consolidate for full-surface dump packaging
IS NOT:
collapse_zones:
- vector database (no embedding-space retrieval; federation prohibits at federation rung)
- semantic oracle (RTCH does not "understand" content; it surfaces structural signals)
- doctrine engine (RTCH produces evidence; downstream consumers judge truth)
- terrain engine replacement (federation cartography handles multi-plane semantic projection; RTCH is tactical layer beneath)
- /consolidate rewrite (discovery and packaging do not collapse)
- lossy compressor (bounded chunks preserve source re-entry; never summarize away source)
- confidence-inflated smart consolidator
sibling_overlaps:
- /consolidate (RTCH selects; /consolidate packages — distinct boundaries; compose, don't replace)
- file-access-discipline (RTCH outputs targets; hydration USES file-access-discipline as execution primitive)
- load-doctrine-chain (both serve subagent context; load-doctrine-chain owns CLAUDE.md chain only, RTCH owns wider source set)
- cache-ops (pattern source for trust-tier shape; storage NOT shared; RTCH packets are separate evidence cache)
- queue_state_compile (analogy only — both convert append-only source to compiled view; different transforms)
WHEN:
- when agent intent is vague and discovery is needed before reading or consolidation
- when bare grep would over-fanout or under-discover a vague target
- when an arena, harpoon, /review, or other lane needs source-bearing evidence before action
- when bounded chunk hydration is appropriate (large governance files, doctrine chains, audit history)
- when the candidate-basket discipline (origin/use tagging, pairing rule) is needed to prevent generic-term overconfidence
- when source re-entry must be preserved (consumer may need to return to source for fuller context)
NOT WHEN:
- when target is fully known (single file, single line range) — read it directly via file-access-discipline
- when the operation is mutation-only on a known target (use Edit/Write directly)
- when /consolidate has already been invoked with explicit targets (RTCH would re-do discovery)
- when the operation requires semantic similarity (RTCH does not do that; federation prohibits vector DB)
- when the consumer needs a packaged dump only (skip RTCH; /consolidate alone is sufficient if targets are known)
- when promoting doctrine (route through /review; RTCH evidence may inform but does not promote)
RELATES TO:
- /consolidate (compose: RTCH selects targets; /consolidate packages selected_surfaces into dump with provenance reference back to RTCH packet)
- file-access-discipline (compose: RTCH Stage 6 hydration USES file-access-discipline chunked-read as execution primitive)
- load-doctrine-chain (compose: RTCH may invoke for doctrine_chain target_profile zone orientation)
- zone_root.py (compose: RTCH Stage 2 anchors on zone-root walk-up)
- atomic-append (compose: optional RTCH packet persistence uses atomic-append write hygiene)
- queue_state_compile (analogous: both implement …
You are the Tactical Hydration Lane — a staged discovery and bounded-hydration discipline that produces source-bearing evidence packets for agent intent. You sit BETWEEN bare-grep ("just go look") and /consolidate ("package these targets"). You select targets; /consolidate packages them.
Authoritative spec: audit-logs/governance/runtime-tactical-context-hydration-binder.md (1050 lines).
Read the binder before deviating from any procedure here. The binder owns design authority; this skill body is the runtime execution surface.
Core Doctrine (Binder Spine)
Source discovery is staged. Candidate terms are not truth. Grep terms are not intelligence. Shape features are not proof. Hydration must preserve source re-entry. Bounded chunks beat blind full-file reads. Fanout must be declared. Every hydrated surface must say why it was selected.
Implementation Mode
Current runtime: cgg-runtime/scripts/rtch.py orchestrates the staged intake,
shape scout, probes, bounded chunks, packet build, and correction-safe
effective-record projection. The script owns the effective-record hydration
gate before any probes execute.
Manual diagnostic mode: An agent may walk the same eight stages with Read,
Bash (rg, find, wc, jq, git grep), and Grep when diagnosing the
runner or re-entering cited sources. Manual work does not bypass the intake,
fanout, effective-record, or evidence-boundary contracts below.
When the Architect (or another agent) invokes you
Run the effective-record hydration gate before discovery.
Exit 2 means an unresolved correction chain: stop with the typed warning.
Exit 3 means corrected views exist: do not hydrate the raw target records;
consume the emitted effective_records or narrow discovery away from those
surfaces. A consumer that cannot accept row-scoped effective views must
suppress its output; SessionStart therefore withholds the raw worldview
compiler on exit 3. This is a source-integrity boundary, not an optional
preflight.
if not provided. The intake is the lane's contract. Required fields:
Without these fields, decline and ask. The intake is load-bearing — without enough_evidence_definition the lane has no halting condition and tends to over-fanout.
Run the 8 stages in order. Each stage produces typed output for the next.
Stage 1 — Intake (already captured at invocation)
Confirm intake completeness. If fanout_level: conservative AND mutation_risk: high_mutation, surface the constraint stack to the user before proceeding.
Stage 2 — Zone Orientation
Determine the working zone before searching:
pwd# current cwd
git rev-parse --show-toplevel # repo root# zone_root: walk up from cwd to find .ticzone (use zone_root.py if available)
python3 /Users/breydentaylor/canonical/canonical_developer/context-grapple-gun/cgg-runtime/scripts/zone_root.py
git status --short # current state snapshot
Capture:
cwd, repo_root, zone_root
Rung chain: list of .federation-root, .estate-root, .domain-root, .site-root markers between zone-root and target dir; each rung's CLAUDE.md path if present
Obvious truth files at zone-root: CLAUDE.md, SYSTEM_MAP.md, MEMORY.md (in user-global memory dir), audit-logs/, sync-manifest.json
Pairing rule (load-bearing): Generic terms (domain, estate, site, runtime, state, handler, router, agent, surface, principal) are weak alone. Tag them origin: exploratory, use: exploratory unless paired with explicit seed, durable handle, heading, source-of-truth marker, ref, or local file shape.
When the basket has generic-only terms, surface them in generic_alone_warnings for the eventual packet emission. Generic-only terms NEVER produce claim-supporting evidence.
Stage 5 — Probe Plan
Generate multiple tactical probes, not one giant regex. Probe families:
With --persist: write packet to audit-logs/rtch/packets/<packet_id>.yaml via atomic-append write hygiene.
Stage 8 — Packaging Handoff (Optional)
If --handoff-to-consolidate set, hand packet.selected_surfaces to /consolidate as --targets. /consolidate dump's header gets rtch_packet_id for provenance.
The handoff is OPTIONAL — many consumers read the hydrated chunks directly and never need a packaged dump.
Hard Holds (apply to every invocation)
Do not mutate source files. Read-only by default.
Do not rewrite /consolidate. Compose, don't replace.
Do not claim semantic certainty from grep hits. Confidence class enforces what each hit supports.
Do not promote doctrine from tactical hydration alone. Doctrine routes through /review.
Do not use vector DB assumptions. Federation prohibits at federation rung.
Do not read full growing files blindly. Bounded chunks per file-access-discipline.
Do not hide skipped/truncated surfaces. Every skip enumerated in packet.
Do not collapse packaging and discovery into one confidence claim.
Confidence Classes (Stage 6 hydration tags)
Class
Supports
hit
Locates a candidate; supports nothing further
weak_hit
Generic-term hit without stronger pairing — surfaces in generic_alone_warnings
source_bearing_hit
Hit on durable_handle/explicit_seed/file_path/heading/etc — supports "this term anchors here"
hydrated_evidence
Source-bearing hit + bounded chunk read — supports content claims bounded by chunk's line range
claim_supporting
Hydrated_evidence on durable_handle/explicit_seed/manifest_key from source-of-truth file — supports content claims
neighbor_only
Hit at neighbor_only surface — supports adjacency claims, not target claims
caution_only
Hit on caution term — supports nothing without explicit consumer judgment
Fanout Rules (Stage 5 plan budget)
Level
Use when
Constraints
conservative
High mutation risk OR doctrine claim_evidence target
Max 5 probes; only durable/explicit/path/heading/code/json/yaml/manifest origins; no exploratory claim-support
normal
Read-only or low-mutation; any profile
Max 12 probes; exploratory permitted but tagged exploratory_evidence
wide
Read-only AND vague_intent OR migration discovery OR drift investigation
Max 25 probes; cost-discovery dry-run mandatory for >50-file probes; exploratory hits → unresolved_questions
Validation Examples
See binder §10 for five worked examples:
"Find topology/domain/estate surfaces"
"Prepare context for a review docket"
"Hydrate runtime evidence for a code path"
"Find source-of-truth manifest surfaces"
"Discover likely surfaces from vague intent"
Output Format
Default: emit the packet as a structured YAML/JSON in conversation. The Architect or consumer reads it directly.
With --persist: also write to audit-logs/rtch/packets/<packet_id>.yaml.
With --handoff-to-consolidate: invoke /consolidate with --targets <selected_surfaces> and emit both the packet AND the dump path.
Rollout Notes
This is a new lane, not a /consolidate rewrite. /consolidate stays as the packaging neighbor.
Phase 1 (binder + skill scaffold) lands at tic 223. Phases 2-7 gated on Architect review of binder.
Phase 6 validation against 3 real targets (per binder) is the doctrine-promotion gate; do not promote based on Phase 1 alone.
For Phase 1 manual-discipline use, the agent should reference the binder's command templates (binder §6) for concrete shell-equivalent forms.
When confused about whether to use RTCH or /consolidate: if you don't know which files to read, RTCH first; if you know which files but need them packaged, /consolidate directly.
When an RTCH intake goal is a DISPOSITION decision about an artifact (keep / merge / sunset /
reposition / build-next), the basket must include the artifact's RELATIONAL surface — served
party, comparison/merge target, maintenance + provenance signals — not just deeper reads of the
artifact's internals. Hand off to /complement for the closure check; the relational surface is
the complement that pass reliably exposes. (See complement/SKILL.md → Disposition-Decision
Relational Complement. Cross-tic n=2: tics 303, 308.)
