incremnt 0.4.0 → 0.6.0

package/README.md

@@ -67,13 +67,21 @@ incremnt login --session-file ~/Downloads/session.json
 | `health summary` / `health ai` | Health metrics and AI summary |
 | `training load` | ATL/CTL/TSB and workload context |
 | `ask history` / `ask show --id <id>` | Coach conversation history |
+| `increment-score current` | Latest Increment Score summary with components, drivers, trend, and data-quality flags |
+| `increment-score history` | Historical Increment Score snapshots |
+| `increment-score upload --file <file>` | Upload Increment Score snapshots |
 | `programs propose --file <file>` | Submit a program proposal |
 | `programs proposals` | List proposals |
 | `programs proposal dismiss --id <id>` | Dismiss a proposal |
+| `programs share create --program-id <id>` | Create a public share token for a program |
+| `programs share list --program-id <id>` | List share artifacts for a program |
+| `programs share fetch --token <token>` | Fetch a publicly shared program |
+| `programs share revoke --share-id <id>` | Revoke a previously issued share |
 | `browse` | Interactive Ink browser for sessions, programs, records, goals, cycles, and health |
 | `tui` | Alias for `browse` |
 | `mcp install` | Register `incremnt-mcp` with Claude Desktop, Claude Code, and Codex CLI |
-| `login` | Authenticate with the hosted sync service |
+| `login` | Authenticate with the hosted sync service (opens browser) |
+| `login --no-browser` | Headless login flow for SSH/Termius/remote shells |
 | `logout` | Clear stored session |
 | `status` | Show current mode, auth state, and config paths |
 | `contract` | Machine-readable command surface for scripts |
@@ -114,7 +122,7 @@ incremnt login --session-file ~/Downloads/session.json
 
 ## MCP Server
 
-The package includes an [MCP](https://modelcontextprotocol.io) server that exposes the same read queries and program proposal commands as tools for AI assistants like Claude.
+The package includes an [MCP](https://modelcontextprotocol.io) server for AI assistants like Claude and Codex.
 
 Run `incremnt mcp install` to auto-register the server with Claude Desktop, Claude Code, and Codex CLI (see [Setup](#setup) above).
 
@@ -135,7 +143,12 @@ The MCP server uses the same auth session as the CLI — run `incremnt login` fi
 
 ### MCP tool surface
 
-The MCP server exposes the same read/write contract as the CLI command surface, including sessions, programs, cycles, goals, health, training load, ask history/show, and program proposal workflows.
+The MCP server exposes two tool families:
+
+- Command-shaped tools from the public CLI contract, including sessions, programs, cycles, goals, health, training load, ask history/show, `increment-score-current`, `increment-score-history`, `increment-score-upload`, program proposals, and program shares.
+- Typed coach read tools for agent-native context retrieval, including `get_increment_score`, `get_recent_sessions`, `get_exercise_history`, `get_next_session`, `get_readiness_snapshot`, `get_body_weight_snapshot`, `get_goal_status`, and `get_records`.
+
+`get_increment_score` returns the same privacy-safe score summary as `increment-score current`: score, snapshot timestamp, formula version, data tier, component scores, positive/negative drivers, day-over-day delta, recent trend, and data-quality flags. It does not expose raw HealthKit values.
 
 You can inspect the exact machine-readable contract at any time:
 

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "incremnt",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "Command-line tool for querying your incremnt strength training data",
   "license": "MIT",
   "type": "module",
+  "engines": {
+    "node": ">=22.0.0"
+  },
   "bin": {
     "incremnt": "./src/index.js",
     "incremnt-mcp": "./src/mcp.js"
@@ -17,15 +20,28 @@
     "test:evals:real": "SUMMARY_EVAL_CASE_SET=anonymized-render node --test test/summary-evals.test.js",
     "evals:stored": "node ./scripts/run-summary-evals.js",
     "evals:stored:render": "node ./scripts/run-render-summary-evals.js",
+    "evals:promptfoo": "promptfoo eval -c promptfooconfig.yaml",
+    "evals:promptfoo:production-replay": "SUMMARY_EVAL_CASE_SET=production-replay promptfoo eval -c promptfooconfig.yaml",
+    "evals:promptfoo:live": "PROMPTFOO_LIVE=1 SUMMARY_EVALS_LIVE=1 promptfoo eval -c promptfooconfig.yaml",
     "evals:workout-bakeoff": "node ./scripts/run-workout-prompt-bakeoff.js",
+    "evals:coach-bakeoff": "node ./scripts/run-production-coach-bakeoff.js",
+    "evals:coach-replay": "node ./scripts/run-production-coach-replay.js",
+    "increment-score:replay": "node ./scripts/run-increment-score-replay.js",
+    "increment-score:replay-data": "node ./scripts/export-increment-score-replay-data.js",
+    "langfuse:smoke": "node ./scripts/smoke-langfuse-score.js",
     "dev:sync-fixture": "node ./scripts/dev-sync-fixture-server.js",
     "postinstall": "node -e \"process.stdout.write('\\n  incremnt MCP server installed.\\n  Run: incremnt mcp install\\n  to register it with Claude and Codex.\\n\\n')\""
   },
   "dependencies": {
+    "@langfuse/tracing": "^5.2.0",
     "@modelcontextprotocol/sdk": "^1.12.1",
     "chalk": "^5.6.2",
-    "ink": "^5.2.1",
-    "react": "^18.3.1",
-    "zod": "^3.24.0"
+    "ink": "^7.0.1",
+    "openai": "^6.34.0",
+    "react": "^19.2.5",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "promptfoo": "^0.121.8"
   }
 }

package/src/anonymize.js

@@ -0,0 +1,12 @@
+import { createHash } from 'node:crypto';
+
+export function anonymizeAccountId(accountId) {
+  if (typeof accountId !== 'string' || !accountId.trim()) {
+    return 'anon:unknown';
+  }
+  const digest = createHash('sha256')
+    .update(`account:${accountId}`)
+    .digest('hex')
+    .slice(0, 12);
+  return `anon:${digest}`;
+}

package/src/coach-bakeoff.js

@@ -0,0 +1,300 @@
+import { askContext, workoutSummaryContext } from './queries.js';
+import { COACH_PROMPT_VARIANTS } from './coach-prompt-variants.js';
+
+export const DEFAULT_COACH_BAKEOFF_MODELS = Object.freeze([
+  'anthropic/claude-haiku-4.5',
+  'openai/gpt-5.4-mini',
+  'google/gemini-3-flash-preview',
+  'z-ai/glm-5.1'
+]);
+
+export const DEFAULT_COACH_REPLAY_CONFIGS = Object.freeze([
+  {
+    name: 'current-haiku',
+    label: 'Current Haiku',
+    model: 'anthropic/claude-haiku-4.5',
+    workoutPrompt: COACH_PROMPT_VARIANTS.current.workoutPrompt,
+    askPrompt: COACH_PROMPT_VARIANTS.current.askPrompt
+  },
+  {
+    name: 'revised-haiku',
+    label: 'Revised Haiku',
+    model: 'anthropic/claude-haiku-4.5',
+    workoutPrompt: COACH_PROMPT_VARIANTS.personality.workoutPrompt,
+    askPrompt: COACH_PROMPT_VARIANTS.warm.askPrompt
+  },
+  {
+    name: 'revised-mini',
+    label: 'Revised GPT-5.4 Mini',
+    model: 'openai/gpt-5.4-mini',
+    workoutPrompt: COACH_PROMPT_VARIANTS.personality.workoutPrompt,
+    askPrompt: COACH_PROMPT_VARIANTS.warm.askPrompt
+  }
+]);
+
+function stableSortByDateDesc(items, selector) {
+  return [...items].sort((lhs, rhs) => String(selector(rhs)).localeCompare(String(selector(lhs))));
+}
+
+function completionDateForSession(session) {
+  return session?.completedAt
+    ?? session?.updatedAt
+    ?? session?.startTime
+    ?? session?.date
+    ?? '';
+}
+
+function buildStoredWorkoutEvalCase(session, snapshotLabel = 'snapshot') {
+  const anyOf = [
+    ...(session.exercises ?? []).map((exercise) => exercise.name),
+    session.dayName
+  ].filter(Boolean);
+
+  return {
+    id: `stored-workout-${session.id}`,
+    name: `Stored workout summary ${session.id}`,
+    surface: 'workout',
+    source: 'stored',
+    snapshotLabel,
+    selector: { sessionId: session.id },
+    output: session.summary?.aiCoachNotes ?? '',
+    metadata: null,
+    requiredMentions: [],
+    requiredAnyOfMentions: anyOf,
+    forbiddenPhrases: ['solid progress', 'trust the process', 'keep it up', 'quality work', 'in a great place', 'continue progressive overload', 'as fatigue accumulates'],
+    forbiddenMentions: [],
+    personaEval: { profile: 'motivated-athlete' },
+    expectNoInsight: false,
+    shouldPass: true
+  };
+}
+
+function buildStoredAskEvalCase(conversation, snapshotLabel = 'snapshot') {
+  return {
+    id: `stored-ask-${conversation.id}`,
+    name: `Stored ask conversation ${conversation.id}`,
+    surface: 'ask',
+    source: 'stored',
+    snapshotLabel,
+    context: { question: '', conversationId: conversation.id },
+    output: extractAskReplay(conversation)?.answer ?? '',
+    metadata: null,
+    requiredMentions: [],
+    requiredAnyOfMentions: [],
+    forbiddenPhrases: [],
+    forbiddenMentions: [],
+    personaEval: { profile: 'motivated-athlete' },
+    expectNoInsight: false,
+    shouldPass: true
+  };
+}
+
+export function findLatestStoredWorkoutSummarySession(snapshot) {
+  return stableSortByDateDesc(
+    (snapshot.sessions ?? []).filter((session) => session?.summary?.aiCoachNotes),
+    (session) => completionDateForSession(session)
+  )[0] ?? null;
+}
+
+export function extractAskReplay(conversation) {
+  if (!conversation || !Array.isArray(conversation.messages)) {
+    return null;
+  }
+
+  const assistantIndex = [...conversation.messages]
+    .map((message, index) => ({ message, index }))
+    .filter(({ message }) => message?.role === 'assistant' && typeof message?.content === 'string' && message.content.trim())
+    .at(-1)?.index;
+
+  if (assistantIndex == null) {
+    return null;
+  }
+
+  let questionIndex = -1;
+  for (let index = assistantIndex - 1; index >= 0; index -= 1) {
+    const message = conversation.messages[index];
+    if (message?.role === 'user' && typeof message?.content === 'string' && message.content.trim()) {
+      questionIndex = index;
+      break;
+    }
+  }
+
+  if (questionIndex === -1) {
+    return null;
+  }
+
+  const history = conversation.messages
+    .slice(0, questionIndex)
+    .filter((message) => ['user', 'assistant'].includes(message?.role))
+    .map((message) => ({ role: message.role, content: message.content }));
+
+  return {
+    question: conversation.messages[questionIndex].content,
+    history,
+    answer: conversation.messages[assistantIndex].content
+  };
+}
+
+export function findLatestAskConversation(snapshot) {
+  return stableSortByDateDesc(
+    (snapshot.askConversations ?? []).filter((conversation) => extractAskReplay(conversation)),
+    (conversation) => conversation?.createdAt ?? ''
+  )[0] ?? null;
+}
+
+export function buildCoachBakeoffTargets(snapshot, { sessionId, conversationId, exclude = new Set() } = {}) {
+  const selectedSession = sessionId
+    ? (snapshot.sessions ?? []).find((session) => session.id === sessionId) ?? null
+    : findLatestStoredWorkoutSummarySession(snapshot);
+  if (!selectedSession) {
+    throw new Error('No workout session with stored AI coach notes found.');
+  }
+
+  const selectedConversation = conversationId
+    ? (snapshot.askConversations ?? []).find((conversation) => conversation.id === conversationId) ?? null
+    : findLatestAskConversation(snapshot);
+  if (!selectedConversation) {
+    throw new Error('No ask conversation with a replayable user/assistant pair found.');
+  }
+
+  const askReplay = extractAskReplay(selectedConversation);
+  if (!askReplay) {
+    throw new Error(`Could not extract ask replay from conversation ${selectedConversation.id}.`);
+  }
+
+  const workout = {
+    sessionId: selectedSession.id,
+    dayName: selectedSession.dayName ?? 'Session',
+    completedAt: completionDateForSession(selectedSession),
+    storedOutput: selectedSession.summary?.aiCoachNotes ?? null,
+    context: workoutSummaryContext(snapshot, selectedSession.id, { exclude })
+  };
+
+  if (!workout.context) {
+    throw new Error(`Could not build workout context for session ${selectedSession.id}.`);
+  }
+
+  return {
+    workout,
+    ask: {
+      conversationId: selectedConversation.id,
+      createdAt: selectedConversation.createdAt ?? null,
+      question: askReplay.question,
+      history: askReplay.history,
+      storedOutput: askReplay.answer,
+      context: askContext(snapshot, { exclude })
+    }
+  };
+}
+
+export function harvestRecentCoachReplayCases(
+  snapshot,
+  { maxWorkoutCases = 5, maxAskCases = 5, exclude = new Set(), snapshotLabel = 'snapshot' } = {}
+) {
+  const askContextText = askContext(snapshot, { exclude });
+
+  const workoutCases = stableSortByDateDesc(
+    (snapshot.sessions ?? []).filter((session) => session?.summary?.aiCoachNotes),
+    (session) => completionDateForSession(session)
+  )
+    .slice(0, maxWorkoutCases)
+    .map((session) => ({
+      id: session.id,
+      surface: 'workout',
+      label: `${session.dayName ?? 'Session'} ${completionDateForSession(session)}`,
+      completedAt: completionDateForSession(session),
+      storedOutput: session.summary?.aiCoachNotes ?? '',
+      context: workoutSummaryContext(snapshot, session.id, { exclude }),
+      evalCase: buildStoredWorkoutEvalCase(session, snapshotLabel)
+    }))
+    .filter((entry) => entry.context);
+
+  const askCases = stableSortByDateDesc(
+    (snapshot.askConversations ?? []).filter((conversation) => extractAskReplay(conversation)),
+    (conversation) => conversation?.createdAt ?? ''
+  )
+    .slice(0, maxAskCases)
+    .map((conversation) => {
+      const replay = extractAskReplay(conversation);
+      return {
+        id: conversation.id,
+        surface: 'ask',
+        label: `Ask ${conversation.createdAt ?? conversation.id}`,
+        createdAt: conversation.createdAt ?? null,
+        question: replay.question,
+        history: replay.history,
+        storedOutput: replay.answer,
+        context: askContextText,
+        evalCase: buildStoredAskEvalCase(conversation, snapshotLabel)
+      };
+    });
+
+  return { workoutCases, askCases };
+}
+
+function formatGenerationLine(result) {
+  const bits = [result.model];
+  if (result.resolvedModel && result.resolvedModel !== result.model) {
+    bits.push(`resolved ${result.resolvedModel}`);
+  }
+  if (result.durationMs != null) {
+    bits.push(`${result.durationMs}ms`);
+  }
+  if (result.fallback) bits.push('fallback');
+  if (result.error) bits.push(`error: ${result.error}`);
+  return bits.join(' | ');
+}
+
+function pushOutputBlock(lines, heading, text, metaLine = null) {
+  lines.push(heading);
+  if (metaLine) lines.push(`- ${metaLine}`);
+  lines.push('');
+  lines.push(text.trim());
+  lines.push('');
+}
+
+export function formatCoachBakeoffMarkdownReport(report) {
+  const lines = [
+    '# Production Coach Bakeoff',
+    '',
+    `- Generated: ${report.generatedAt}`,
+    `- User: ${report.userId}`,
+    `- Workout session: ${report.targets.workout.sessionId} (${report.targets.workout.dayName}, ${report.targets.workout.completedAt})`,
+    `- Ask conversation: ${report.targets.ask.conversationId} (${report.targets.ask.createdAt})`,
+    `- Models: ${report.models.join(', ')}`,
+    `- Variants: ${report.variants.map((variant) => `${variant.name} (${variant.label})`).join(', ')}`,
+    ''
+  ];
+
+  lines.push('## Stored Baseline', '');
+  pushOutputBlock(lines, '### Workout', report.targets.workout.storedOutput ?? 'No stored workout summary.');
+  lines.push(`### Ask question`, '', report.targets.ask.question.trim(), '');
+  pushOutputBlock(lines, '### Ask stored answer', report.targets.ask.storedOutput ?? 'No stored ask answer.');
+
+  lines.push('## Context', '');
+  lines.push('### Workout context', '');
+  lines.push('```text');
+  lines.push(report.contextPreview.workout.trim());
+  lines.push('```', '');
+  lines.push('### Ask context', '');
+  lines.push('```text');
+  lines.push(report.contextPreview.ask.trim());
+  lines.push('```', '');
+
+  for (const surface of ['workout', 'ask']) {
+    lines.push(`## ${surface === 'workout' ? 'Workout summary bakeoff' : 'Ask follow-up bakeoff'}`, '');
+    for (const variant of report.variants) {
+      lines.push(`### ${variant.label}`, '');
+      for (const result of report.results.filter((entry) => entry.surface === surface && entry.variant === variant.name)) {
+        pushOutputBlock(
+          lines,
+          `#### ${result.model}`,
+          result.error ? `[generation failed]\n${result.error}` : result.output,
+          formatGenerationLine(result)
+        );
+      }
+    }
+  }
+
+  return `${lines.join('\n')}\n`;
+}

package/src/coach-facts.js

@@ -0,0 +1,100 @@
+export const COACH_FACT_KINDS = Object.freeze(['preference', 'constraint', 'injury', 'goal_signal', 'tone']);
+
+const COACH_FACT_KIND_SET = new Set(COACH_FACT_KINDS);
+
+const PROMPT_INJECTION_PATTERNS = [
+  /\b(ignore|disregard|override)\b.{0,40}\b(instructions?|rules?|system|developer|previous)\b/i,
+  /\b(system prompt|developer message|jailbreak|act as|you are chatgpt)\b/i
+];
+
+const DERIVED_TRAINING_PATTERNS = [
+  /\b(e1rm|1rm|one[-\s]?rep max|estimated one[-\s]?rep max)\b/i,
+  /\b(personal record|rep pr|volume pr|\bpr\b)\b/i,
+  /\b(tonnage|training volume|total volume|session count|sets completed|missed sets)\b/i,
+  /\b\d+(?:\.\d+)?\s*(?:kg|kgs|kilograms?|lb|lbs|pounds?)\b.{0,40}\b(bench|squat|deadlift|press|curl|row|pulldown|leg|lift|rep|set|volume)\b/i,
+  /\b(bench|squat|deadlift|press|curl|row|pulldown|leg|lift)\b.{0,40}\b\d+(?:\.\d+)?\s*(?:kg|kgs|kilograms?|lb|lbs|pounds?)\b/i,
+  /\b\d+(?:\.\d+)?\s*x\s*\d+\b/i,
+  /\b(?:trained|completed|logged|did)\s+\d+\s+(?:sessions?|workouts?)\b/i
+];
+
+const EPHEMERAL_PATTERNS = [
+  /\b(today|yesterday|tomorrow|this week|last week|next week|last session|latest session|recent session)\b/i,
+  /\b(current|currently|latest|recent)\s+(?:best|e1rm|1rm|volume|pr|record|session|workout)\b/i
+];
+
+export function normalizeCoachFactText(value) {
+  return String(value ?? '').replace(/\s+/g, ' ').trim();
+}
+
+export function normalizeCoachFactKind(value) {
+  return String(value ?? '').trim();
+}
+
+export function isCoachFactKind(value) {
+  return COACH_FACT_KIND_SET.has(normalizeCoachFactKind(value));
+}
+
+export function coachFactPolicyViolation(candidate) {
+  const kind = normalizeCoachFactKind(candidate?.kind);
+  const fact = normalizeCoachFactText(candidate?.fact);
+  if (!isCoachFactKind(kind)) return 'invalid_kind';
+  if (fact.length < 3) return 'too_short';
+  if (fact.length > 160) return 'too_long';
+  if (!/^the trainee\b/i.test(fact)) return 'not_third_person';
+  if (PROMPT_INJECTION_PATTERNS.some((pattern) => pattern.test(fact))) return 'prompt_injection';
+  if (DERIVED_TRAINING_PATTERNS.some((pattern) => pattern.test(fact))) return 'derived_training_fact';
+  if (EPHEMERAL_PATTERNS.some((pattern) => pattern.test(fact))) return 'ephemeral_fact';
+  return null;
+}
+
+export function normalizeCoachFactCandidate(candidate) {
+  if (!candidate || typeof candidate !== 'object') return null;
+  const normalized = {
+    kind: normalizeCoachFactKind(candidate.kind),
+    fact: normalizeCoachFactText(candidate.fact),
+    confidence: Number(candidate.confidence ?? 0.7)
+  };
+  if (coachFactPolicyViolation(normalized)) return null;
+  return {
+    ...normalized,
+    confidence: Number.isFinite(normalized.confidence) ? Math.max(0, Math.min(1, normalized.confidence)) : 0.7
+  };
+}
+
+export function coachFactConflictKey(candidate) {
+  const kind = normalizeCoachFactKind(candidate?.kind);
+  const fact = normalizeCoachFactText(candidate?.fact).toLowerCase();
+  if (kind === 'tone' && /\b(concise|brief|short|terse|direct|succinct|detailed|thorough|long[-\s]?form|explain)\b/.test(fact)) {
+    return 'tone:verbosity';
+  }
+  return null;
+}
+
+export function coachFactConflictSearchPattern(candidate) {
+  const key = coachFactConflictKey(candidate);
+  if (key !== 'tone:verbosity') return null;
+  const fact = normalizeCoachFactText(candidate?.fact).toLowerCase();
+  if (/\b(concise|brief|short|terse|direct|succinct)\b/.test(fact)) {
+    return '\\m(detailed|thorough|long[-[:space:]]?form|explain)\\M';
+  }
+  if (/\b(detailed|thorough|long[-\s]?form|explain)\b/.test(fact)) {
+    return '\\m(concise|brief|short|terse|direct|succinct)\\M';
+  }
+  return null;
+}
+
+export function dedupeCoachFactCandidates(candidates, { limit = 3 } = {}) {
+  const byKey = new Map();
+  for (const candidate of Array.isArray(candidates) ? candidates : []) {
+    const normalized = normalizeCoachFactCandidate(candidate);
+    if (!normalized) continue;
+    const key = coachFactConflictKey(normalized) ?? `${normalized.kind}:${normalized.fact.toLowerCase()}`;
+    const existing = byKey.get(key);
+    if (!existing || normalized.confidence >= existing.confidence) {
+      byKey.set(key, normalized);
+    }
+  }
+  return [...byKey.values()]
+    .sort((a, b) => b.confidence - a.confidence)
+    .slice(0, limit);
+}

package/src/coach-prompt-variants.js

@@ -0,0 +1,106 @@
+import { ASK_PROMPT, SECURITY_PREAMBLE, WORKOUT_COACH_PROMPT } from './openrouter.js';
+
+export const WARM_WORKOUT_COACH_PROMPT = `${SECURITY_PREAMBLE}You are a training coach reviewing a completed session. Write a short post-workout note in 2-3 sentences, single paragraph.
+
+Goal order:
+1. Leave the user feeling good about training.
+2. Surface one real signal from the log.
+3. Mention a miss lightly, only if it matters.
+
+Style:
+- Lead with a warm, grounded opener.
+- Start with what went well or what the session covered before any watch item.
+- One observation is enough. Use exact exercises and numbers.
+- If you mention muscle coverage or session balance, anchor it to the logged exercises. Do not use generic filler.
+- If the strongest watch item is minor, keep it brief and neutral.
+- If the note would add nothing beyond the visible workout log, return exactly: NO_INSIGHT.
+
+Rules:
+- No bullet points, no questions.
+- No audit language like "fell short of plan volume", "concern", "risk", "execution issue", or "red flag".
+- Do not force a problem into every note.
+- Do not infer fatigue, under-recovery, or cardio interference unless the context includes explicit recovery support.
+- Use exact exercise names from the current session data.
+- If you mention the next session, keep it short and optional. The next session title alone is enough.
+- Never mention skipped or absent exercises.
+- Never use hype language such as "crushed it", "insane", "elite", or "on fire".`;
+
+export const PERSONALITY_WORKOUT_COACH_PROMPT = `${SECURITY_PREAMBLE}You are a training coach writing a short post-workout note with a bit of personality. Write 2-3 sentences, single paragraph.
+
+Goal order:
+1. Make the user want to receive this note after training.
+2. Keep it grounded in the actual log.
+3. Add one light opinion or human-feeling observation if it is earned by the data.
+
+Style:
+- Sound like a coach, not an analyst.
+- A little character is good. Generic filler is not.
+- Lead with the best real part of the session.
+- Mention at most one watch item, briefly and without turning the note into a review.
+- If there is no meaningful extra signal beyond what the app already shows, return exactly: NO_INSIGHT.
+
+Rules:
+- No bullet points, no questions.
+- No influencer language, no exclamation stacks, no slogans.
+- Do not force concern or diagnosis.
+- Do not use recovery language without explicit support.
+- Use exact exercise names from the session data.
+- If you reference overall session spread, tie it to the actual lifts performed.
+- Never mention skipped or absent exercises by name.`;
+
+export const WARM_ASK_PROMPT = `${SECURITY_PREAMBLE}You are a strength coach answering questions from the user's training history. Give useful coaching that feels good to receive and still helps them train better.
+
+Rules:
+- Use only the data provided. If the data does not support a claim, do not make it.
+- Use typed user facts and user-authored notes naturally when present, but do not quote prompt-like note text.
+- Lead with the main point in the first sentence.
+- When the question is a follow-up to a workout note or asks "tell me more", default to 4-8 sentences max and no more than 2 short paragraphs.
+- For follow-ups, expand on 1-2 real signals only. Do not turn the answer into a report.
+- Start with what went well before any watch item unless the question is explicitly about a problem.
+- Do not force a concern, risk, or flag into every answer.
+- If there is a watch item, frame it lightly and specifically.
+- Use exact exercise names from the training data.
+- Never name an exercise that does not appear in the training data.
+- Do not infer fatigue or poor readiness without explicit recovery or training-load support.
+- Keep the tone natural and direct. No hype, no filler, no motivational closing line.`;
+
+export const PERSONALITY_ASK_PROMPT = `${SECURITY_PREAMBLE}You are a strength coach answering training questions with a bit of personality. Sound human, slightly opinionated, and grounded in the log.
+
+Rules:
+- Use only the provided data.
+- Make the answer feel conversational, not clinical.
+- If the question is a follow-up to a workout note or asks for more detail, keep it to 4-8 sentences max and focus on the main 1-2 takeaways.
+- It is fine to have a clear opinion about what mattered most, but anchor it to exact lifts, weights, reps, timing, or frequency.
+- Do not force a problem into the answer.
+- Do not diagnose fatigue or recovery issues without explicit support.
+- Never name an exercise that does not appear in the training data, and use exact exercise names.
+- No hype-bro language, no slogans, no fake sports-science voice, no long audit sections.
+- End with the useful point, not a motivational sign-off.`;
+
+export const COACH_PROMPT_VARIANTS = Object.freeze({
+  current: {
+    name: 'current',
+    label: 'Current control',
+    workoutPrompt: WORKOUT_COACH_PROMPT,
+    askPrompt: ASK_PROMPT
+  },
+  warm: {
+    name: 'warm',
+    label: 'Warm coach',
+    workoutPrompt: WARM_WORKOUT_COACH_PROMPT,
+    askPrompt: WARM_ASK_PROMPT
+  },
+  personality: {
+    name: 'personality',
+    label: 'More personality',
+    workoutPrompt: PERSONALITY_WORKOUT_COACH_PROMPT,
+    askPrompt: PERSONALITY_ASK_PROMPT
+  }
+});
+
+export const DEFAULT_COACH_BAKEOFF_VARIANTS = Object.freeze(['current', 'warm', 'personality']);
+
+export function resolveCoachPromptVariant(name) {
+  if (!name) return COACH_PROMPT_VARIANTS.current;
+  return COACH_PROMPT_VARIANTS[name] ?? null;
+}

package/src/contract.js

@@ -1,4 +1,4 @@
-export const contractVersion = 6;
+export const contractVersion = 11;
 
 export const capabilities = {
   readOnly: false,
@@ -161,6 +161,24 @@ export const commandSchema = [
     options: [
       { name: 'token', type: 'string', required: true, description: 'Program share token' }
     ]
+  },
+  {
+    command: 'increment-score current',
+    id: 'increment-score-current',
+    description: 'Show the latest Increment Score snapshot summary',
+    options: [
+      { name: 'historyDays', type: 'number', required: false, description: 'Recent score history window (default 14, max 60)' }
+    ]
+  },
+  {
+    command: 'increment-score history',
+    id: 'increment-score-history',
+    description: 'List historical Increment Score snapshots for the authenticated user',
+    options: [
+      { name: 'from', type: 'string', required: false, description: 'Earliest snapshot_at (ISO 8601)' },
+      { name: 'to', type: 'string', required: false, description: 'Latest snapshot_at (ISO 8601)' },
+      { name: 'limit', type: 'number', required: false, description: 'Max snapshots to return (default 200, max 1000)' }
+    ]
   }
 ];
 
@@ -194,7 +212,7 @@ export const writeCommandSchema = [
   {
     command: 'programs share create',
     id: 'program-share-create',
-    description: 'Create or reuse a share token for one program',
+    description: 'Create a new share token for one program',
     usage: 'programs share create --program-id <program-id>',
     options: [
       { name: 'program-id', type: 'string', required: true, description: 'Program ID' }
@@ -212,10 +230,19 @@ export const writeCommandSchema = [
   {
     command: 'programs share revoke',
     id: 'program-share-revoke',
-    description: 'Revoke a previously issued program share token',
-    usage: 'programs share revoke --token <token>',
+    description: 'Revoke a previously issued program share by id',
+    usage: 'programs share revoke --share-id <share-id>',
     options: [
-      { name: 'token', type: 'string', required: true, description: 'Program share token' }
+      { name: 'share-id', type: 'string', required: true, description: 'Program share id' }
+    ]
+  },
+  {
+    command: 'increment-score upload',
+    id: 'increment-score-upload',
+    description: 'Upload one or more Increment Score snapshots for the authenticated user',
+    usage: 'increment-score upload --file <file>',
+    options: [
+      { name: 'file', type: 'string', required: true, description: 'Path to JSON file with { snapshots: [...] }' }
     ]
   }
 ];