PRD: Copilot SDK Hooks Integration — Migration Avenues & Per-Hook Improvement Plan

[diberry]

PRD: Copilot SDK Hooks Integration for Squad

Executive Summary

Squad already wraps @github/copilot-sdk (v0.1.32) and has a HookPipeline with PreToolUse/PostToolUse hooks plus 5 built-in governance policies. However, the Copilot SDK exposes 6 lifecycle hooks — Squad only leverages 2 of them for tool governance. The remaining 4 hooks (onSessionStart, onUserPromptSubmitted, onSessionEnd, onErrorOccurred) plus deeper use of the existing 2 represent a significant opportunity to move coordinator logic from fragile prompt templates into reliable, programmatic hooks.

This PRD maps each Copilot SDK hook to concrete Squad improvements, categorizes what's already in the product vs. what requires new work, and provides business value analysis for each.

---

Migration Avenues: What's In vs. Not In Squad Today

Already In Squad (Leverage Existing)

Capability	Where It Lives	Status
HookPipeline class	packages/squad-sdk/src/hooks/index.ts	Production (384 lines)
PreToolUseHook interface	hooks/index.ts	Production
PostToolUseHook interface	hooks/index.ts	Production
File-write guard policy	Built-in policy	Production
Shell restriction policy	Built-in policy	Production
Ask-user rate limiting	Built-in policy	Production
PII scrubbing (post-tool)	Built-in policy	Production
Reviewer lockout hook	ReviewerLockoutHook	Production
Copilot SDK adapter	packages/squad-sdk/src/adapter/	Production
SquadSessionHooks type	adapter/types.ts	Production
Hook governance sample	samples/hook-governance/	Production
Hook docs	docs/reference/tools-and-hooks.md	Production
Coordinator accepts hookPipeline	coordinator/index.ts via CoordinatorDeps	Production

Not In Squad (Requires New Work)

Capability	Copilot SDK Hook	Gap
Session start context injection	onSessionStart	Squad passes hooks config but doesn't implement lifecycle logic
Prompt interception / rewriting	onUserPromptSubmitted	Not wired — all prompt processing is in coordinator prose
Session teardown / cleanup	onSessionEnd	Not wired — cleanup is manual or Scribe-driven
Error-driven model fallback	onErrorOccurred	Not wired — fallback chains are prose in squad.agent.md
Dynamic policy from decisions.md	onPreToolUse (extended)	Static policies only — no decision-driven enforcement
Auto-Scribe on file writes	onPostToolUse (extended)	Scribe is manually spawned by coordinator after batches
Agent spawn lifecycle hooks	N/A (Squad-specific)	LifecycleManager.spawnAgent() has no hook points
Routing middleware	N/A (Squad-specific)	Router is deterministic, not pluggable

Partially In Squad (Needs Extension)

Capability	Current State	What's Missing
onPreToolUse	5 static policies	Dynamic policies from team decisions; per-agent workspace boundaries
onPostToolUse	PII scrubbing only	Auto-detect .squad/ writes to queue Scribe; audit logging
Adapter hook passthrough	Types defined, plumbing exists	No default Squad-level implementations registered

---

Hook-by-Hook Improvement Plan

Hook 1: onSessionStart — Auto-Context Loading

What it does: Fires when a Copilot session begins (new or resumed). Can inject additional context.

Current Squad behavior: Every spawn prompt manually instructs agents to "read history.md, read decisions.md, check skills/". This is 200-400 tokens of boilerplate per spawn, and agents sometimes skip reads.

Proposed improvement:

• Register an onSessionStart hook that automatically resolves and injects:
  • Agent's history.md (last N entries)
  • Current decisions.md snapshot
  • Relevant skills from .squad/skills/ matching the agent's domain
  • identity/now.md (current focus) and identity/wisdom.md (team wisdom)
• Context is injected programmatically — not as prompt instructions that depend on the agent reading files

Implementation scope:

• Extend SquadSessionHooks in adapter/types.ts
• Create packages/squad-sdk/src/hooks/session-start.ts
• Wire into LifecycleManager.spawnAgent() session creation
• Make context sources configurable via squad.config.ts

Executive Summary — Business Value:

For Squad product: Reduces coordinator prompt template complexity by ~30%. Makes context loading reliable instead of advisory. Eliminates a class of bugs where agents "forget" to read decisions or history.

For Squad customers: Agents start faster and with better context. Users no longer need to debug why an agent missed a team decision. Token savings of 200-400 tokens per spawn (compounding across multi-agent fan-outs).

---

Hook 2: onUserPromptSubmitted — Directive Detection and Prompt Enhancement

What it does: Fires every time a user sends a message. Can rewrite, filter, or augment the prompt.

Current Squad behavior: The coordinator pattern-matches directive signals ("always", "never", "from now on") in prose logic within squad.agent.md. Directives are captured to decisions/inbox/ manually. No prompt rewriting occurs.

Proposed improvement:

• Register an onUserPromptSubmitted hook that:
  1. Scans for directive signals and auto-writes to decisions/inbox/ before LLM processing
  2. Injects relevant team context (recent decisions, active ceremonies) as additional context
  3. Applies team-specific prompt conventions (e.g., "always include error handling" from decisions.md)
  4. Detects agent-addressed messages ("Ripley, fix X") and adds routing hints

Implementation scope:

• Create packages/squad-sdk/src/hooks/prompt-submitted.ts
• Directive pattern matcher (regex + heuristics)
• Context injector reading from decisions.md
• Wire into session creation

Executive Summary — Business Value:

For Squad product: Moves directive capture from fragile coordinator prose into deterministic code. Enables prompt-level governance (e.g., enterprise teams can enforce "all prompts must include security context"). Opens the door to prompt analytics.

For Squad customers: Directives are never missed — every "always do X" is captured automatically. Team conventions are enforced at the prompt level, not just documented. Reduces cognitive load on the coordinator, freeing context for actual work.

---

Hook 3: onPreToolUse (Extended) — Dynamic Policy Enforcement

What it does: Fires before every tool execution. Can allow, deny, or modify the call.

Current Squad behavior: 5 static policies (file guards, shell restrictions, rate limiting, PII, reviewer lockout). Policies are defined in code, not configurable from team state.

Proposed improvement:

• Add decision-driven policies: parse decisions.md for enforceable rules (e.g., "never use jQuery" blocks tool calls that write jQuery imports)
• Add per-agent workspace boundaries: each agent can only write to files matching their charter scope
• Add ceremony gates: block certain tool categories during active ceremonies (e.g., no file writes during a design review)
• Make policy configuration declarative via squad.config.ts or .squad/policies/

Implementation scope:

• Create packages/squad-sdk/src/hooks/dynamic-policies.ts
• Decision parser that extracts enforceable rules from decisions.md
• Per-agent scope resolver using charter metadata
• Policy config schema in squad.config.ts

Executive Summary — Business Value:

For Squad product: Transforms decisions.md from a passive document into an active enforcement layer. This is a unique differentiator — no other AI team framework auto-enforces team decisions at the tool level.

For Squad customers: Team decisions actually stick. When the team decides "use Tailwind, not Bootstrap", agents physically cannot introduce Bootstrap. Enterprise teams get auditable policy enforcement without custom tooling.

---

Hook 4: onPostToolUse (Extended) — Auto-Scribe and Audit Trail

What it does: Fires after every tool execution. Can transform results, redact data, or trigger side effects.

Current Squad behavior: PII scrubbing only. Scribe is manually spawned by the coordinator after work batches complete. No automatic audit trail of tool usage.

Proposed improvement:

• Auto-Scribe trigger: detect when agents write to .squad/ files and automatically queue Scribe merge/log work
• Audit logging: log every tool call (name, args summary, success/fail, duration) to .squad/orchestration-log/
• Cross-agent notification: when Agent A writes a file that Agent B's charter covers, flag it
• Result caching: cache expensive tool results (e.g., large file reads) for reuse within the session

Implementation scope:

• Create packages/squad-sdk/src/hooks/post-tool-audit.ts
• Scribe auto-trigger detection (file path pattern matching)
• Audit log writer (append-only, structured JSON)
• Cross-agent scope overlap detector

Executive Summary — Business Value:

For Squad product: Eliminates the coordinator's manual Scribe spawning — one of the most error-prone parts of the post-work flow. Makes "silent success detection" obsolete because every tool call is logged.

For Squad customers: Complete audit trail of everything agents did, without any configuration. Enterprise compliance teams get the logging they need. Auto-Scribe means decisions and logs are always current, even if the coordinator context overflows.

---

Hook 5: onSessionEnd — Automatic Cleanup and Metrics

What it does: Fires when a session ends.

Current Squad behavior: No automatic cleanup. History summarization, log archival, and metrics are ad-hoc (Scribe does it when told, or it doesn't happen).

Proposed improvement:

• Auto-archive: if history.md exceeds threshold, summarize and archive on session end
• Metrics capture: tokens used, tools called, files modified, decisions made — write to .squad/metrics/
• Ralph trigger: if work items remain, notify Ralph or write to .squad/identity/now.md
• Session summary: auto-generate a brief session recap for .squad/log/

Implementation scope:

• Create packages/squad-sdk/src/hooks/session-end.ts
• History size checker + summarizer
• Metrics collector (reads from session state)
• Ralph integration (writes to identity/now.md)

Executive Summary — Business Value:

For Squad product: Solves the "history.md grows forever" problem permanently. Makes metrics collection automatic instead of opt-in. Ensures every session leaves a clean state for the next one.

For Squad customers: No more manual cleanup. Session metrics enable cost tracking and optimization. Teams can see exactly what happened in every session without digging through logs.

---

Hook 6: onErrorOccurred — Programmatic Model Fallback

What it does: Fires when any error occurs during the session.

Current Squad behavior: Model fallback chains are documented in squad.agent.md as prose instructions. The coordinator must interpret and execute them manually. Rate limits, model unavailability, and context overflow are handled ad-hoc.

Proposed improvement:

• Model fallback as code: define fallback chains (Premium to Standard to Fast to nuclear) in squad.config.ts and execute them automatically
• Rate limit backoff: detect rate limit errors and apply automatic exponential backoff + retry
• Context overflow recovery: detect context overflow and automatically summarize and retry with compressed context
• Error alerting: notify the user or log when errors exceed thresholds

Implementation scope:

• Create packages/squad-sdk/src/hooks/error-recovery.ts
• Model fallback chain resolver (reads from config)
• Rate limit detector + backoff logic
• Context overflow detector + summarization trigger

Executive Summary — Business Value:

For Squad product: Moves the most failure-prone coordinator logic (model fallback, rate limit handling) from prose instructions into deterministic code. Eliminates ~10-15% of session failures caused by the coordinator mishandling fallbacks.

For Squad customers: Sessions are more resilient. Model unavailability is invisible — the system automatically falls back. Rate limits don't crash sessions. Enterprise teams with model restrictions get automatic routing without coordinator confusion.

---

Hook 7: Agent Spawn Lifecycle (Squad-Specific — Not in Copilot SDK)

What it does: New hook points in LifecycleManager.spawnAgent() — onBeforeSpawn, onAfterSpawn, onSpawnError.

Current Squad behavior: LifecycleManager.spawnAgent() is opaque — no extension points. All spawn customization must happen in the coordinator's prompt template.

Proposed improvement:

• onBeforeSpawn: validate agent config, check resource limits, apply team policies before creating a session
• onAfterSpawn: register the agent in a session registry, notify other agents, start monitoring
• onSpawnError: retry with different model, alert user, log failure details

Implementation scope:

• Extend LifecycleManager in packages/squad-sdk/src/agents/lifecycle.ts
• Define SpawnLifecycleHooks interface
• Wire into coordinator's dispatch flow

Executive Summary — Business Value:

For Squad product: Makes agent spawning extensible for the first time. Plugin authors can customize spawn behavior without forking Squad. Enables features like agent resource quotas, spawn rate limiting, and A/B testing of agent configurations.

For Squad customers: Enterprises can enforce spawn policies (e.g., max 5 concurrent agents, only premium models for security reviews). Plugin marketplace can offer spawn-time customizations.

---

Implementation Priority

Priority	Hook	Effort	Impact	Rationale
P0	onErrorOccurred (model fallback)	Medium	High	Directly reduces session failures — most impactful reliability win
P0	onSessionStart (auto-context)	Medium	High	Token savings compound across every spawn; eliminates context-loading bugs
P1	onPostToolUse (auto-Scribe)	Medium	High	Removes manual Scribe spawning — simplifies coordinator significantly
P1	onPreToolUse (dynamic policies)	High	High	Unique differentiator but complex to parse decisions into enforceable rules
P2	onSessionEnd (cleanup/metrics)	Low	Medium	Quality-of-life; prevents state rot over time
P2	onUserPromptSubmitted (directives)	Medium	Medium	Nice-to-have; current prose-based detection works adequately
P3	Spawn lifecycle hooks	High	Medium	Foundational for plugin ecosystem but not blocking current features

Success Metrics

• Session failure rate drops from ~10% to less than 3% (model fallback + error recovery)
• Tokens per spawn reduced by 200-400 (auto-context replaces prompt boilerplate)
• Scribe coverage reaches 100% of sessions (auto-trigger vs manual)
• Decision enforcement goes from 0% (advisory) to 100% (programmatic)
• Customer satisfaction: zero "my agent forgot the team decision" reports

---

This PRD was generated from an investigation of Squad's current hook system, Copilot SDK documentation, and gap analysis. See the Copilot SDK hooks docs for SDK reference.

[github-actions]

🏗️ Squad Triage — Flight (Lead)

Issue: #151 — PRD: Copilot SDK Hooks Integration — Migration Avenues & Per-Hook Improvement Plan
Assigned to: FIDO (Quality Owner)
Reason: Issue relates to testing/quality work

@copilot evaluation: 🔴 Not suitable — issue involves work outside the coding agent's capability profile.

Team roster:

• Flight (Lead) → label: squad:flight
• Procedures (Prompt Engineer) → label: squad:procedures
• EECOM (Core Dev) → label: squad:eecom
• FIDO (Quality Owner) → label: squad:fido
• PAO (DevRel) → label: squad:pao
• CAPCOM (SDK Expert) → label: squad:capcom
• CONTROL (TypeScript Engineer) → label: squad:control
• Surgeon (Release Manager) → label: squad:surgeon
• Booster (CI/CD Engineer) → label: squad:booster
• GNC (Node.js Runtime) → label: squad:gnc
• Network (Distribution) → label: squad:network
• RETRO (Security) → label: squad:retro
• INCO (CLI UX & Visual Design) → label: squad:inco
• GUIDO (VS Code Extension) → label: squad:guido
• Telemetry (Aspire & Observability) → label: squad:telemetry
• VOX (REPL & Interactive Shell) → label: squad:vox
• DSKY (TUI Engineer) → label: squad:dsky
• Sims (E2E Test Engineer) → label: squad:sims
• Handbook (SDK Usability) → label: squad:handbook
• Ralph (Work Monitor) → label: squad:ralph
• @copilot (Coding Agent) → label: squad:copilot

To reassign, remove the current squad:* label and add the correct one.

[diberry]

Team Review Summary — PRD: Copilot SDK Hooks Integration

Verdict: APPROVE WITH CONDITIONS (4/4 reviewers)

All four team members approve the strategic direction. None recommend sending it back. All flagged pre-conditions that must be resolved before engineering starts.

---

Kermit (Lead/PM) — Strategic Review

Verdict: Approve with conditions

• Strategic alignment is strong — moves Squad from advisory governance to enforced governance (key differentiator)
• Reorder priorities: Ship onSessionStart before onErrorOccurred — token savings compound immediately and are visible to customers
• Clarify ceremony gating in Hook 3 — how does "block tool categories during ceremonies" work mechanically?
• Add performance budgets — hooks run on every tool call; need explicit latency targets

Miss Piggy (Product/Docs) — Requirements Review

Verdict: Approve with 5 must-fix changes

1. Directive patterns undefined — what regex/heuristics detect "always/never" signals? Need a spec
2. Decision parsing contract — how does decisions.md prose become enforceable rules? Need a schema
3. Scoping clarifications — per-agent workspace boundaries need a concrete example
4. Config schemas — squad.config.ts additions need type definitions before implementation
5. Race condition handling — multiple agents writing to decisions/inbox simultaneously needs addressing

Gonzo (Infrastructure) — Technical Feasibility Review

Verdict: Approve with 6 pre-conditions

1. SDK version pinning — use exact version (not ^0.1.32) for pre-1.0 stability
2. Hook error handling contract — what happens when a hook throws? Must not crash the session
3. Performance testing — regex on every prompt + decision parsing on every tool call could add 10-20ms; pre-compile patterns, cache parsing
4. Schema for enforceable decisions — structured format (YAML/block), not prose inference
5. CI automation — hook tests must run in CI pipeline
6. Concurrency guards — multiple hooks writing to .squad/ files simultaneously

Scooter (Quality/Process) — Quality Review

Verdict: Approve with changes (2 critical gaps)

1. Testing strategy is a critical gap — no test scenarios defined; created a 40+ test case matrix for all 7 hooks
2. Broken dependency chain — priority table ignores hook interdependencies (Hook 1 depends on Hook 4's adapter work)
3. Phased rollout needed — ship in 4 releases (v0.2.0 through v0.2.3), not all at once
4. Backward compatibility risk — existing configs need opt-in model + migration guide to prevent duplicate context injection
5. Telemetry plan — success metrics require instrumentation that doesn't exist yet

---

Consolidated Must-Do List Before Engineering Starts

#	Item	Owner	Source
1	Define enforceable decision schema (structured format, not prose parsing)	PRD author	Piggy, Gonzo
2	Write test matrix for all 7 hooks (40+ scenarios)	Quality	Scooter
3	Define performance budgets per hook (latency targets)	Infra	Kermit, Gonzo
4	Pin SDK version exactly	Infra	Gonzo
5	Define hook error handling contract (no session crashes)	PRD author	Gonzo
6	Plan phased rollout (4 releases, respect dependency chain)	PM	Scooter
7	Design opt-in/migration path for existing users	PRD author	Scooter
8	Spec directive detection patterns	PRD author	Piggy
9	Add config type definitions for squad.config.ts	PRD author	Piggy

---

Full reviews available in .squad/decisions/inbox/ — kermit-hooks-prd-review.md, piggy-hooks-prd-review.md, gonzo-hooks-prd-review.md, scooter-hooks-prd-review.md

[diberry]

Correction & Addendum: All 8 Copilot Hooks (Not 6)

The original PRD listed 6 hooks from the Copilot SDK. The full VS Code Agent hooks surface has 8 hooks — the SDK's 6 plus 2 additional hooks exposed in the VS Code agent lifecycle. This addendum corrects the count and adds business cases for the missing hooks.

Complete Hook Map (8 Hooks)

#	Hook	SDK (@github/copilot-sdk)	VS Code Agent	Squad Status
1	Pre-tool execution	onPreToolUse	PreToolUse	✅ Supported via HookPipeline
2	Post-tool execution	onPostToolUse	PostToolUse	✅ Supported via HookPipeline
3	Session start	onSessionStart	SessionStart	❌ Types defined, not wired
4	User prompt submitted	onUserPromptSubmitted	UserPromptSubmit	❌ Types defined, not wired
5	Session end	onSessionEnd	Stop	❌ Types defined, not wired
6	Error occurred	onErrorOccurred	— (SDK only)	❌ Types defined, not wired
7	Pre-context compaction	—	PreCompact	❌ Not in Squad at all
8	Subagent lifecycle	—	SubagentStart / SubagentStop	❌ Not in Squad at all

---

Hook 7: PreCompact — Context Window Preservation

What it does: Fires before the agent's context window is compacted (pruned/truncated to fit token limits). Gives you a chance to export or preserve state before data is lost.

Why this matters for Squad: Squad agents accumulate context over long sessions — decisions, history, tool results. When context compaction triggers, critical information can be silently lost. This hook lets Squad preserve it.

Business Cases

#	Business Case	Who Benefits
62	Save decisions before compaction — export any decisions the agent made but hasn't written to inbox yet	Every Squad user (data safety)
63	Checkpoint history — write agent's accumulated learnings to history.md before they're truncated	Long sessions, complex tasks
64	Context budget alerting — notify user "context is 90% full, compaction imminent" so they can break the task	Interactive CLI users
65	State serialization — serialize in-memory state (variables, counters, partial results) to .squad/sessions/ for recovery	Autonomous SDK pipelines
66	Priority-based retention — tag certain context as "must keep" (decisions, user directives) and "can drop" (verbose tool output) so compaction preserves what matters	Enterprise teams with large contexts
67	Trigger session split — when compaction is about to fire, automatically start a new session with a compressed summary rather than losing detail	Batch processing, Ralph loops
68	Metrics on context pressure — log when compaction fires, how much was dropped, which agents hit limits most often	Squad product team (optimization)

Executive Summary — Business Value:

For Squad product: Solves the "context overflow" problem — the #2 cause of agent degradation in long sessions (after rate limits). Makes Squad viable for complex, multi-hour work sessions without silent data loss.

For Squad customers: Your agent's work doesn't disappear mid-session. Decisions are preserved. History is checkpointed. If context gets tight, the system adapts instead of silently forgetting.

---

Hook 8: SubagentStart / SubagentStop — Multi-Agent Lifecycle

What it does: SubagentStart fires when a child agent (subagent) is spawned. SubagentStop fires when it finishes. This is the multi-agent orchestration hook — it gives the coordinator visibility and control over the entire agent tree.

Why this matters for Squad: This IS Squad's core model. Squad spawns subagents constantly (coordinator → specialist agents). Today, the coordinator manages this entirely through prompt instructions. These hooks make it programmatic.

Business Cases

#	Business Case	Who Benefits
69	Agent spawn registry — track every active agent (who, when, what task, which model) in real-time	Coordinator reliability
70	Concurrent agent limits — block spawn if team already has N agents running (prevent runaway fan-outs)	Cost control, rate limit prevention
71	Agent cost allocation — tag each subagent spawn with a cost center, track spend per-agent	Engineering managers, SaaS billing
72	Spawn-time policy enforcement — validate agent config against team policies before it starts (right model? right scope? approved charter?)	Enterprise governance
73	Auto-context handoff — when subagent starts, automatically pass relevant context from parent (decisions, recent changes, relevant files)	Multi-agent coordination quality
74	Subagent completion tracking — when subagent stops, automatically collect results, update coordinator state, trigger follow-up work	Coordinator reliability (replaces manual read_agent)
75	Silent success detection (solved) — when subagent stops, check if it produced output. If not, check filesystem for artifacts. Log either way	Eliminates the "7-10% silent success" bug
76	Auto-Scribe on agent completion — when any subagent stops, trigger Scribe to log what it did	Audit completeness without coordinator intervention
77	Agent timeout enforcement — if subagent runs longer than threshold, kill it and route to a different agent	Resilience for stuck agents
78	Agent performance metrics — track spawn-to-complete duration, token usage, tool calls per agent for optimization	Squad product team, enterprise dashboards
79	Cascade failure prevention — if 3 subagents fail in a row, stop spawning and alert user (circuit breaker at spawn level)	Autonomous pipelines (Ralph)
80	A/B model testing at spawn — randomly assign different models to subagents, measure quality/speed/cost per model	Squad product team (model selection optimization)
81	Reviewer lockout at spawn time — before spawning a revision agent, verify they're not locked out of the artifact	Reviewer protocol enforcement (currently checked too late)

Executive Summary — Business Value:

For Squad product: This is the single most impactful hook for Squad. Every problem the coordinator struggles with today — silent success, manual result collection, agent timeout, spawn policy enforcement — becomes solvable with programmatic subagent lifecycle hooks. This hook alone could eliminate 50%+ of coordinator failure modes.

For Squad customers: Agent spawning becomes observable and controllable. Cost limits are enforced at spawn time. Stuck agents get killed automatically. Results are collected reliably. The "sometimes agents work, sometimes they don't" experience becomes deterministic.

---

Updated Summary Table (All 8 Hooks, 81 Business Cases)

Hook	Status in Squad	Business Cases	Top Impact
onPreToolUse	✅ Supported	#1–15 (15 cases)	Agent boundaries, tool governance
onPostToolUse	✅ Supported	#16–28 (13 cases)	Audit trail, PII scrubbing
onSessionStart	❌ Types only	#29–35 (7 cases)	Auto-context, tenant config
onUserPromptSubmitted	❌ Types only	#36–43 (8 cases)	Directive capture, prompt governance
onSessionEnd	❌ Types only	#44–52 (9 cases)	Metrics, cleanup, billing
onErrorOccurred	❌ Types only	#53–61 (9 cases)	Model fallback, resilience
PreCompact	❌ Not in Squad	#62–68 (7 cases)	Context preservation, session continuity
SubagentStart/Stop	❌ Not in Squad	#69–81 (13 cases)	Multi-agent orchestration, spawn governance

Revised Priority (with new hooks)

Priority	Hook	Rationale
P0	SubagentStart/Stop	Highest impact for Squad — solves coordinator's core reliability problems
P0	onErrorOccurred	Directly reduces session failures
P0	onSessionStart	Token savings, context reliability
P1	PreCompact	Prevents silent data loss in long sessions
P1	onPostToolUse (extended)	Auto-Scribe, audit trail
P1	onPreToolUse (extended)	Dynamic policies
P2	onSessionEnd	Cleanup, metrics
P2	onUserPromptSubmitted	Directive capture