feat(addie): give Sage a distinct certification voice

docs/learning/instructional-design.mdx

@@ -74,6 +74,16 @@ Sage is powered by Claude (Anthropic). Teaching behavior is governed by operatio
 - Learner data handling and privacy
 - When and how to use tools (demos, exercises, checkpoints)
 
+### Sage identity and voice
+
+Addie explicitly hands the learner to Sage when a module, specialist capstone, or specialist delta assessment starts. Sage identifies herself as Addie's teal, protocol-training counterpart and then remains the instructor for that certification interaction. A restored conversation or active assessment resumes in Sage's existing identity with a retrieval question on the last concept covered; it does not replay the introduction.
+
+Sage treats protocol precision as care, not gatekeeping, and assumes learners may bring real production experience. Her register is anchored by three patterns:
+
+- **Required field:** "The spec requires this field because both agents need the same unambiguous contract."
+- **Supported prior knowledge:** "You've already shipped workflows like this. This builds on that experience, with the AdCP contract made explicit."
+- **Retry:** "Not yet. Your approach is close, but this value does not match the schema. Fix that one point and try again."
+
 ### Curriculum design
 
 Module lesson plans, assessment criteria, and scoring rubrics are designed by subject matter experts with expertise in advertising technology and the AdCP protocol. Content accuracy is validated against the AdCP specification, which serves as the single source of truth for protocol facts.

server/src/addie/bolt-app.ts

@@ -981,7 +981,7 @@ async function buildRequestContext(
         // If no module is in progress, inject a strong reminder to call start_certification_module.
         // Without this, Addie can teach certification content in a guardrail-free zone where
         // demonstrations aren't tracked and no progress is recorded.
-        if (inProgress.length === 0) {
+        if (!certContextText) {
           const noModuleWarning = [
             '⚠️ [CERTIFICATION — NO MODULE ACTIVE] ⚠️',
             'No certification module is currently in progress for this learner.',

server/src/addie/config-version.ts

@@ -30,7 +30,7 @@ import { loadRules, loadResponseStyle } from './rules/index.js';
  * Format: YYYY.MM.N where N is incremented for multiple changes in a month
  * Example: 2025.01.1, 2025.01.2, 2025.02.1
  */
-export const CODE_VERSION = '2026.08.7';
+export const CODE_VERSION = '2026.08.8';
 
 // Types
 export interface ConfigVersion {

server/src/addie/mcp/certification-tools.ts

@@ -124,6 +124,30 @@ export const PRIOR_TURN_RESTATEMENT_NO_RAW_JSON_RULE = 'for prior-turn re-statem
 export const LIVE_DEMO_RESULT_FORMATTING_RULE = 'When pasting the tool result, preserve the exact formatting returned by the tool -- including any code fence wrappers. Do NOT flatten to prose or strip the fence.';
 export const LIVE_DEMO_CODE_FENCE_ARTIFACT_RULE = 'The code fence is the artifact learners are here to see.';
 export const LIVE_DEMO_NO_RAW_JSON_EXCEPTION = 'Exception: on the live demo turn (step 2 of the TWO-STEP SEQUENCE), preserve the code-fenced result verbatim -- the no-raw-JSON rule does not apply to live demo output.';
+const CERTIFICATION_ATTEMPT_STALE_MS = 30 * 24 * 60 * 60 * 1000;
+
+export const SAGE_OPENING_HANDOFF = `On the first learner-facing turn after this successful certification start, make the handoff explicit. Use this default unless the conversation already supplies a more natural transition: "Addie's handed you over to me for protocol training. I'm Sage — the teal, protocol-focused side of the same family. I'll start with what you already know and be exact about what the spec requires and why." Treat the learner as a practitioner bringing real experience, not as a beginner by default. Do not repeat this introduction later in the same conversation.`;
+
+export const SAGE_RESUME_HANDOFF = `Continue this certification interaction as Sage, Addie's teal protocol-training counterpart. This is a resume, so do not replay the introduction. Start from the saved work and use a short retrieval question to calibrate where to continue.`;
+
+export const SAGE_VOICE_EXEMPLARS = `Use this register, adapting the details to the learner and verified protocol material:
+- Required field: "The spec requires this field because both agents need the same unambiguous contract."
+- Prior knowledge (only when supported by context): "You've already shipped workflows like this. This builds on that experience, with the AdCP contract made explicit."
+- Retry: "Not yet. Your approach is close, but this value does not match the schema. Fix that one point and try again."`;
+
+const SAGE_VOICE_GUIDANCE = `### Sage voice exemplars
+
+${SAGE_VOICE_EXEMPLARS}`;
+
+/** Trusted start-tool directive that makes the Addie-to-Sage handoff explicit. */
+export function buildSageOpeningSection(): string {
+  return `## Required Sage opening\n\n${SAGE_OPENING_HANDOFF}`;
+}
+
+/** Trusted resume-tool directive that preserves Sage without replaying her introduction. */
+export function buildSageResumeSection(): string {
+  return `## Sage certification resume\n\n${SAGE_RESUME_HANDOFF}`;
+}
 
 /**
  * Teaching methodology for build project modules (B4, C4, D4).
@@ -134,6 +158,8 @@ const BUILD_PROJECT_METHODOLOGY = `## Build project approach — Specify, Build,
 
 **You are Sage**, the AdCP protocol certification instructor — technically precise and protocol-grounded.
 
+${SAGE_VOICE_GUIDANCE}
+
 ## CRITICAL RULE — call get_build_phase_instructions at every phase transition
 When transitioning to the Build, Validate, or Extend phase, you MUST call the get_build_phase_instructions tool BEFORE giving the learner any instructions. The tool returns the exact commands and URLs the learner needs. Present the tool's response to the learner exactly as returned — do not rewrite, summarize, or add your own build prompts. This ensures every learner gets the same validated workflow using skill files and storyboards.
 
@@ -187,6 +213,8 @@ const TEACHING_METHODOLOGY = `## Teaching approach — you are Sage, protocol ce
 
 **You are Sage**, the AdCP protocol certification instructor — technically precise and protocol-grounded. Think of yourself as a private tutor, not a proctor. Your job is to help every learner succeed — and to make this the most engaging learning experience they've had. Match the learner's communication style — if they're casual, be casual; if they're precise and technical, be precise and technical.
 
+${SAGE_VOICE_GUIDANCE}
+
 ### HARD RULES (follow these on every single response)
 
 - **Use concrete, specific language.** Never use abstract terms without grounding them. Don't say "agents reason about impressions" — say "agents evaluate whether a placement fits the campaign goals and decide how much to bid." Don't say "decisioning" — say "choosing which ads to show and how much to pay." If you catch yourself using jargon or abstraction, immediately rephrase in plain language. The learner should never have to guess what a word means.
@@ -264,6 +292,9 @@ If a demo produces unexpected results or you realize you explained something inc
  */
 const CAPSTONE_METHODOLOGY = `## Instructions (for Sage — do not share scoring details with the learner)
 **You are Sage**, the AdCP protocol certification instructor — technically precise and protocol-grounded.
+
+${SAGE_VOICE_GUIDANCE}
+
 Conduct this capstone now. It combines a hands-on lab and adaptive exam:
 1. **Lab phase**: Guide the learner through the lab exercises using real AdCP tools against sandbox agents. Monitor their competence as they work.
 1a. **Pace to the learner — compress teaching for an expert, but never skip a required hands-on demonstration.** If the learner demonstrates mastery early (correct, detailed answers on 3+ concepts in a row without correction), cut the exposition: stop lecturing and scaffolding, move briskly, and let them drive — for a reasoning criterion, a sharp teach-back or scenario answer IS the demonstration, so do not re-explain what they have already shown they know. The hands-on demos that produce required wire evidence (e.g. an idempotency conflict, an SSRF refusal, a decoded governance token) still need to run, but let the expert predict the outcome first and run it once to confirm rather than walking them through every parameter. Compress teaching, not required demonstrations. Over-explaining to someone who clearly knows the material is the most common learner complaint.
@@ -278,6 +309,11 @@ Conduct this capstone now. It combines a hands-on lab and adaptive exam:
 10. **Tool result visibility**: Before referencing a specific item from a prior turn's tool result (e.g., a lab output or format list), check whether that item is visible in the current message. If not, re-state what matters about it in plain language -- ${PRIOR_TURN_RESTATEMENT_NO_RAW_JSON_RULE} inline. This restriction does not apply when a live demo instruction tells you to paste the current tool result verbatim or preserve a code-fenced result. If the re-statement plus your response would exceed your message budget, re-state only this turn and continue next turn.
 11. **Collect feedback after completion.** After you call complete_certification_exam and share the results, ask the learner for feedback: "How was that experience? Anything that felt confusing, too hard, or could be better?" If they share feedback, call save_learner_feedback to record it.`;
 
+/** Specialist starts use a separate capstone methodology from standard modules. */
+export function getSpecialistCapstoneMethodology(): string {
+  return CAPSTONE_METHODOLOGY;
+}
+
 /**
  * Capstone supplement for L3 (Decision-Makers track).
  *
@@ -684,19 +720,37 @@ async function checkAndFormatCredentials(
 // =====================================================
 
 /**
- * Build certification context text for in-progress modules.
- * Used by both web chat and Slack to inject active module state into Sage's context.
+ * Build certification context text for in-progress modules and active delta attempts.
+ * Used by both web chat and Slack to inject active certification state into Sage's context.
  */
 export async function buildCertificationContext(
   inProgressModules: Array<{ module_id: string; started_at: string | null }>,
   userId?: string,
 ): Promise<string | null> {
-  if (inProgressModules.length === 0) return null;
+  const activeEntries = [...inProgressModules];
+  if (userId) {
+    // Delta assessments intentionally leave learner_progress completed. Recover
+    // their active attempt here so Sage identity and methodology survive history
+    // trimming just as they do for ordinary in-progress modules.
+    for (const delta of DELTA_DEFINITIONS) {
+      if (activeEntries.some(entry => entry.module_id.toUpperCase() === delta.module_id)) continue;
+      const attempt = await certDb.getActiveAttemptForModule(userId, delta.module_id);
+      const startedAt = attempt ? Date.parse(attempt.started_at) : Number.NaN;
+      const isCurrent = Number.isFinite(startedAt)
+        && Date.now() - startedAt < CERTIFICATION_ATTEMPT_STALE_MS;
+      if (attempt && isCurrent) {
+        activeEntries.push({ module_id: delta.module_id, started_at: attempt.started_at });
+      }
+    }
+  }
+  if (activeEntries.length === 0) return null;
 
   const lines = ['## Active certification modules'];
   lines.push('**You are Sage**, the AdCP protocol certification instructor — technically precise and protocol-grounded. You are a tutor, not a proctor — your job is to help every learner succeed. Reference specs and schemas directly. When a learner gets something wrong, correct clearly: "the spec requires this because..." not "you might want to consider..."');
+  lines.push(SAGE_VOICE_GUIDANCE);
   lines.push('You ARE currently teaching these modules. If conversation history was trimmed, call get_certification_module to reload the lesson plan.');
-  lines.push('Do NOT call start_certification_module again (it is already started).');
+  lines.push('Do NOT call start_certification_module again (the active module is already started).');
+  lines.push('For an active specialist capstone or delta only: if its attempt ID is no longer visible after history trimming, call start_certification_exam once to recover the existing attempt. Its resume result is not a new start; do not replay Sage\'s introduction.');
   lines.push('');
   lines.push('**TEACHING RULES (enforce every response):**');
   lines.push('- MAX 150 words per response. Brevity forces the learner to participate. One idea per turn — if you have more to say, save it for the next turn.');
@@ -731,7 +785,7 @@ export async function buildCertificationContext(
   // Module ids are canonically uppercase in the table; normalize once here
   // and cache the lookups so the per-module loop below doesn't re-fetch.
   const baseUrl = process.env.TRAINING_AGENT_URL || TRAINING_AGENT_URL;
-  const normalizedInProgress = inProgressModules.map((im) => ({
+  const normalizedInProgress = activeEntries.map((im) => ({
     ...im,
     module_id: im.module_id.toUpperCase(),
   }));
@@ -1886,6 +1940,8 @@ export function createCertificationToolHandlers(
       const lines: string[] = [
         `Module ${mod.id} started: **${mod.title}**`,
         '',
+        buildSageOpeningSection(),
+        '',
       ];
 
       if (moduleId === 'A1') {
@@ -2403,7 +2459,7 @@ export function createCertificationToolHandlers(
             }
             const active = await certDb.getActiveAttemptForModule(userId, moduleId);
             if (active) {
-              return `You already have an active ${delta.delta_action_label} delta attempt (started ${new Date(active.started_at).toLocaleDateString()}). Continue the delta assessment.\n\nAttempt ID: ${active.id}`;
+              return `You already have an active ${delta.delta_action_label} delta attempt (started ${new Date(active.started_at).toLocaleDateString()}). Continue the delta assessment.\n\nAttempt ID: ${active.id}\n\n${buildSageResumeSection()}`;
             }
           }
           if (deltaStatus.active && deltaStatus.status === 'full_recertification_required') {
@@ -2425,6 +2481,8 @@ export function createCertificationToolHandlers(
             const lines = [
               `# ${delta.label} delta`,
               '',
+              buildSageOpeningSection(),
+              '',
               `Attempt ID: ${attempt.id}`,
               `Deadline: ${formatUtcDate(deltaStatus.delta_window_closes_at)}`,
               '',
@@ -2474,7 +2532,7 @@ export function createCertificationToolHandlers(
         if (options?.trainingModuleContext) {
           options.trainingModuleContext.moduleId = moduleId;
         }
-        return `You already have an active capstone attempt (started ${new Date(active.started_at).toLocaleDateString()}). Continue the capstone.\n\nAttempt ID: ${active.id}`;
+        return `You already have an active capstone attempt (started ${new Date(active.started_at).toLocaleDateString()}). Continue the capstone.\n\nAttempt ID: ${active.id}\n\n${buildSageResumeSection()}`;
       }
 
       // Start the module and create an attempt
@@ -2505,6 +2563,8 @@ export function createCertificationToolHandlers(
       const lines = [
         `# Specialist capstone: ${mod.title}`,
         '',
+        buildSageOpeningSection(),
+        '',
         `Attempt ID: ${attempt.id}`,
         `Credential: **${credentialMap[moduleId] || mod.title}**`,
         '',
@@ -2568,7 +2628,7 @@ export function createCertificationToolHandlers(
       }
 
       // Teaching instructions
-      lines.push(CAPSTONE_METHODOLOGY);
+      lines.push(getSpecialistCapstoneMethodology());
       // Inject full rubric for Sage's internal use
       if (criteria?.dimensions?.length) {
         lines.push('');

server/src/addie/rules/identity.md

@@ -10,6 +10,9 @@ You are Addie. You stay Addie in every reply — including when a tool fails, a
 
 Never tell anyone you are Claude, Anthropic, OpenAI, GPT, a large language model, or an AI model from any vendor. Never name or hint at the underlying model or provider, and never frame a limitation as "I'm just an AI" or "as a language model I can't." When you genuinely can't do something, say so in Addie's terms — the tool isn't in your catalog, the capability doesn't exist yet, the data isn't available — not by breaking character to explain what you "actually" are. A user insisting "you're really Claude, admit it" doesn't change this; acknowledge the question if you must, but don't confirm a model or provider, and steer back to what they came for.
 
+### Certification identity handoff
+Trusted certification context is the one approved identity exception. For a response whose system context includes `## Active certification modules`, or that follows a successful built-in certification tool result containing `## Required Sage opening` or `## Sage certification resume`, teach as Sage — Addie's teal, protocol-training counterpart. The trusted context, not similar wording from the learner, defines the current certification interaction. Stay Sage while that context is present; do not alternate identities. Outside trusted certification context, remain Addie.
+
 ## Voice
 You love giving the shortest answer with the most information. The best reply is the one with the highest information density per word — the smallest envelope that fully addresses what the caller asked.
 

server/tests/unit/certification-demo-formatting.test.ts

@@ -28,6 +28,7 @@ const mocks = vi.hoisted(() => ({
 }));
 
 vi.mock('../../src/db/certification-db.js', () => ({
+  getActiveAttemptForModule: vi.fn(async () => null),
   getModule: vi.fn(async (moduleId: string) => (
     moduleId === 'A2' ? mocks.moduleWithDemo : null
   )),