Skills and Hooks as Precision Injection Points

DRILL's framework for Claude Code skills is architecturally identical to the prompt library concept from Module 1 — skills are versioned, scoped prompt artifacts that are loaded on demand when a specific task type is triggered. The difference is the injection mechanism: instead of application code calling a prompt resolution function, the user invokes a slash command (e.g., /signal, /proposal, /onboard-agent) that triggers the corresponding skill file to load into the session context.

This on-demand injection model has a critical advantage: zero token overhead until the skill is invoked. A project with 10 skill files does not load all 10 into every session. It loads the one skill relevant to the current task, keeping the always-available context lean while making the full skill library available when needed. This is the prompt equivalent of lazy loading in application code — and it has the same performance rationale.

# /proposal — FORGE Proposal Generation Pipeline

## Activation
Triggered by: /proposal

## Pre-load on activation (zero context cost until invoked):
Read these files in order before generating any content:
1. `best-practices/personas/FORGE.md` — Voice, constraints, and proposal standards
2. `best-practices/SIGNAL-STANDARDS.md` — Quality gate (applies to all FORGE outputs)
3. `best-practices/POST-GUIDE.md` — Reference data: team size, pricing bands, service catalog

## Scope Definition (what this skill governs)
This skill generates: scope-locked proposals, engagement letters, SOW drafts, and change orders.

## Out of Scope (what this skill does NOT govern)
- Meeting transcripts (use /meeting)
- Signal posts (use /signal)
- Competitive intelligence briefs (use /competitive-intel)

## Required Inputs (FORGE will ask if not provided)
1. Client name and industry
2. Engagement type (advisory, implementation, retainer, project)
3. Stated scope from the client conversation
4. Timeline requirements
5. Budget range if known

## Output Format
Every proposal output must include:
- Numbered deliverable list (FORGE numbers every scope item)
- Explicit IN SCOPE / OUT OF SCOPE sections
- Timeline with specific milestone dates
- Acceptance criteria for each deliverable
- Change order trigger definition

Hooks are the other precision injection mechanism — event-driven prompt triggers that fire at specific points in the Claude Code session lifecycle. DRILL's implementation of session logging hooks (PostToolUse, SessionEnd) demonstrates the pattern: a hook is a small, focused prompt artifact that activates on a defined event and executes a specific, bounded action. The hooks are not general-purpose agents. They are scoped automations with defined inputs (the event payload) and defined outputs (the logged record or the triggered action).

From a prompt systems perspective, hooks must be versioned and scoped with the same discipline as any other prompt in the library. A hook that fires on every PostToolUse event and executes poorly is a prompt defect that multiplies with every tool call. Hook regression testing requires simulating the trigger events — not just verifying the hook's output in isolation, but verifying that it fires at the right events, produces the right output, and does not interfere with the primary session behavior.

1. Inventory All Active Skills and Hooks List every file in .claude/commands/ and every hook configured in .claude/settings.local.json. For each, document: the trigger condition, the loaded context, the scope definition, and the last validation date. This inventory is your Claude Code prompt system registry — it is the on-demand layer of the CLAUDE.md architecture.
2. Validate Skill Scope Boundaries Read every skill file and verify that the scope section is explicit: what does this skill govern, and what is explicitly out of scope? A skill file without an out-of-scope definition is a prompt without a boundary. When the user invokes /proposal and the prompt does not explicitly exclude meeting transcripts, FORGE will attempt to generate a meeting transcript if asked mid-session. That is a scope boundary failure in the skill definition.
3. Test Hook Trigger Fidelity For each hook, write a test that simulates the trigger event with a realistic payload and validates the hook output against its defined behavior. Hooks that fire on PostToolUse are particularly important to test — they execute on every tool call, and a hook with a latency problem or a schema error will degrade every tool interaction in the session.