incremnt 0.1.15 → 0.1.17

package/README.md

@@ -2,13 +2,15 @@
 
 Command-line tool and MCP server for querying your [incremnt](https://incremnt.app) strength training data.
 
-## Install
+## Setup
 
 ```bash
 npm install -g incremnt
+incremnt login
+incremnt mcp install   # registers with Claude Desktop, Claude Code, and Codex CLI
 ```
 
-This gives you two commands: `incremnt` (CLI) and `incremnt-mcp` (MCP server).
+This gives you two commands: `incremnt` (CLI) and `incremnt-mcp` (MCP server). The `mcp install` step auto-registers the MCP server with Claude Desktop, Claude Code, and Codex CLI — restart your AI assistant for it to take effect.
 
 ## CLI
 
@@ -44,6 +46,8 @@ If `--input` is omitted, the CLI checks `INCREMNT_SNAPSHOT`, then `ONEMORE_SNAPS
 | `sessions show --id <id>` | Details for a single session |
 | `programs current` | Active program state |
 | `programs list` | All programs |
+| `cycles list [--program-id <id>]` | Completed cycle summaries |
+| `cycles show --id <id>` | Details for a completed cycle summary |
 | `exercises history --name <name>` | Set-by-set history for an exercise |
 | `records` | Personal records (best e1RM per exercise) |
 | `login` | Authenticate with the hosted sync service |
@@ -58,6 +62,7 @@ If `--input` is omitted, the CLI checks `INCREMNT_SNAPSHOT`, then `ONEMORE_SNAPS
 | `--pretty` | Human-readable formatted output (default is JSON) |
 | `--input <path>` | Path to a local `.onemore.json` snapshot |
 | `--limit <n>` | Limit number of results (for `sessions list`) |
+| `--program-id <id>` | Filter cycle summaries to a program |
 
 ### Exercise matching
 
@@ -65,26 +70,23 @@ If `--input` is omitted, the CLI checks `INCREMNT_SNAPSHOT`, then `ONEMORE_SNAPS
 
 ## MCP Server
 
-The package includes an [MCP](https://modelcontextprotocol.io) server that exposes the same queries as tools for AI assistants like Claude.
+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.
 
-### Setup
+Run `incremnt mcp install` to auto-register the server with Claude Desktop, Claude Code, and Codex CLI (see [Setup](#setup) above).
 
-Add to your Claude Code project config (`.mcp.json`):
+To register manually instead, add to your Claude Code project config (`.mcp.json`):
 
 ```json
 {
   "mcpServers": {
     "incremnt": {
       "type": "stdio",
-      "command": "npx",
-      "args": ["-y", "incremnt-mcp"]
+      "command": "incremnt-mcp"
     }
   }
 }
 ```
 
-Or run directly: `npx incremnt-mcp`
-
 The MCP server uses the same auth session as the CLI — run `incremnt login` first.
 
 ## License

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "incremnt",
-  "version": "0.1.15",
+  "version": "0.1.17",
   "description": "Command-line tool for querying your incremnt strength training data",
   "license": "MIT",
   "type": "module",
@@ -14,7 +14,7 @@
   "scripts": {
     "test": "node --test",
     "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.\\n\\n')\""
+    "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": {
     "@modelcontextprotocol/sdk": "^1.12.1",

package/src/contract.js

@@ -115,6 +115,31 @@ export const commandSchema = [
     options: [
       { name: 'id', type: 'string', required: true, description: 'Cycle summary ID' }
     ]
+  },
+  {
+    command: 'health summary',
+    id: 'health-summary',
+    description: 'Health metrics summary (resting HR, HRV, VO2 Max, sleep, cardio)',
+    options: [
+      { name: 'days', type: 'number', required: false, description: 'Last N days (default: 14)' }
+    ]
+  },
+  {
+    command: 'ask history',
+    id: 'ask-history',
+    description: 'List past AI coach conversations',
+    options: [
+      { name: 'limit', type: 'number', required: false, description: 'Max conversations to return (default: 20)' }
+    ]
+  },
+  {
+    command: 'ask show',
+    id: 'ask-show',
+    description: 'Show a full AI coach conversation',
+    usage: 'ask show --id <conversation-id>',
+    options: [
+      { name: 'id', type: 'string', required: true, description: 'Conversation ID' }
+    ]
   }
 ];
 

package/src/lib.js

@@ -167,7 +167,26 @@ export async function runCli(argv, stdout, stderr) {
       await fs.writeFile(cliPath, JSON.stringify(cliConfig, null, 2) + '\n');
       installed.push(`  Claude Code:    ${cliPath}`);
 
-      stdout.write(`Registered incremnt MCP server in:\n${installed.join('\n')}\n\nRestart Claude for the changes to take effect.\n`);
+      // Codex CLI
+      const codexPath = path.join(os.homedir(), '.codex', 'config.toml');
+      try {
+        let codexConfig = '';
+        try {
+          codexConfig = await fs.readFile(codexPath, 'utf8');
+        } catch { /* file doesn't exist yet */ }
+        const block = `[mcp_servers.incremnt]\ncommand = "${mcpBin}"\n`;
+        if (!codexConfig.includes('[mcp_servers.incremnt]')) {
+          await fs.mkdir(path.dirname(codexPath), { recursive: true });
+          await fs.writeFile(codexPath, codexConfig + (codexConfig && !codexConfig.endsWith('\n') ? '\n' : '') + block);
+          installed.push(`  Codex CLI:      ${codexPath}`);
+        } else {
+          installed.push(`  Codex CLI:      ${codexPath} (already registered)`);
+        }
+      } catch (error) {
+        installed.push(`  Codex CLI:      skipped (${error.message})`);
+      }
+
+      stdout.write(`Registered incremnt MCP server in:\n${installed.join('\n')}\n\nRestart Claude/Codex for the changes to take effect.\n`);
       return 0;
     } catch (error) {
       stderr.write(`${error.message}\n`);

package/src/mcp.js

@@ -1,18 +1,15 @@
 #!/usr/bin/env node
 
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { z } from 'zod';
-import { commandSchema } from './contract.js';
+import { commandSchema, writeCommands, writeCommandSchema } from './contract.js';
 import { readSessionState } from './state.js';
 import { createTransport } from './transport.js';
 
-const server = new McpServer({
-  name: 'incremnt',
-  version: '0.1.0'
-});
-
-for (const cmd of commandSchema) {
+function commandShape(cmd) {
   const shape = {};
 
   for (const opt of cmd.options) {
@@ -22,39 +19,69 @@ for (const cmd of commandSchema) {
     shape[opt.name] = field;
   }
 
-  server.tool(cmd.id, cmd.description, shape, async (args) => {
-    try {
-      const sessionState = await readSessionState();
-      const transport = await createTransport({}, sessionState);
+  return shape;
+}
+
+export function registerMcpTools(server, {
+  readSessionStateFn = readSessionState,
+  createTransportFn = createTransport
+} = {}) {
+  for (const cmd of [...commandSchema, ...writeCommandSchema]) {
+    server.tool(cmd.id, cmd.description, commandShape(cmd), async (args) => {
+      try {
+        const sessionState = await readSessionStateFn();
+        const transport = await createTransportFn({}, sessionState);
+
+        if (transport.expired) {
+          return {
+            content: [{ type: 'text', text: 'Session expired. Run `incremnt login` to re-authenticate.' }],
+            isError: true
+          };
+        }
+
+        const result = writeCommands.has(cmd.id)
+          ? await transport.executeWriteCommand(cmd.id, args)
+          : await transport.executeReadCommand(cmd.id, args);
 
-      if (transport.expired) {
         return {
-          content: [{ type: 'text', text: 'Session expired. Run `incremnt login` to re-authenticate.' }],
-          isError: true
+          content: [{ type: 'text', text: JSON.stringify(result, null, 2) }]
         };
-      }
+      } catch (error) {
+        const message = error?.message ?? String(error);
 
-      const result = await transport.executeReadCommand(cmd.id, args);
-      return {
-        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }]
-      };
-    } catch (error) {
-      const message = error?.message ?? String(error);
+        if (error?.code === 'SNAPSHOT_NOT_FOUND') {
+          return {
+            content: [{ type: 'text', text: 'Not logged in. Run `incremnt login` first.' }],
+            isError: true
+          };
+        }
 
-      if (error?.code === 'SNAPSHOT_NOT_FOUND') {
         return {
-          content: [{ type: 'text', text: 'Not logged in. Run `incremnt login` first.' }],
+          content: [{ type: 'text', text: message }],
           isError: true
         };
       }
+    });
+  }
+
+  return server;
+}
 
-      return {
-        content: [{ type: 'text', text: message }],
-        isError: true
-      };
-    }
+export function createMcpServer(deps) {
+  const server = new McpServer({
+    name: 'incremnt',
+    version: '0.1.0'
   });
+
+  return registerMcpTools(server, deps);
 }
 
-const transport = new StdioServerTransport();
-await server.connect(transport);
+async function main() {
+  const transport = new StdioServerTransport();
+  const server = createMcpServer();
+  await server.connect(transport);
+}
+
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  await main();
+}

package/src/openrouter.js

@@ -1,13 +1,83 @@
-// Default model used only for local dev. In production the sync service
-// sets OPENROUTER_MODEL via env vars (currently Claude 3.5 Haiku).
-const DEFAULT_MODEL = 'meta-llama/llama-3.1-8b-instruct:free';
-const DEFAULT_TIMEOUT_MS = 15_000;
+const SUMMARY_MODEL_CHAIN = [
+  'deepseek/deepseek-v3.2-20251201',
+  'anthropic/claude-3.5-haiku'
+];
+const ASK_MODEL_CHAIN = [
+  'anthropic/claude-3.5-haiku',
+  'deepseek/deepseek-v3.2-20251201'
+];
+const TIMEOUT_PER_MODEL_MS = 12_000;
+const ASK_TIMEOUT_MS = 8_000;
 const DEFAULT_MAX_TOKENS = 500;
 
-const CYCLE_SUMMARY_PROMPT = `You are a strength coach reviewing a trainee's completed training cycle (typically one week). Write 3-4 short paragraphs separated by blank lines.
+async function callOpenRouter(messages, { apiKey, models, temperature, maxTokens, timeoutMs }) {
+  const chain = models ?? SUMMARY_MODEL_CHAIN;
+  const timeout = timeoutMs ?? TIMEOUT_PER_MODEL_MS;
+  const errors = [];
+
+  const startTotal = Date.now();
+
+  for (const model of chain) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeout);
+    const startModel = Date.now();
+
+    try {
+      const response = await fetch('https://openrouter.ai/api/v1/chat/completions', {
+        method: 'POST',
+        headers: {
+          'Authorization': `Bearer ${apiKey}`,
+          'Content-Type': 'application/json',
+          'HTTP-Referer': 'https://incremnt.app',
+          'X-Title': 'incremnt'
+        },
+        body: JSON.stringify({
+          model,
+          messages,
+          max_tokens: maxTokens ?? DEFAULT_MAX_TOKENS,
+          temperature: temperature ?? 0.5
+        }),
+        signal: controller.signal
+      });
+
+      if (!response.ok) {
+        const text = await response.text().catch(() => '');
+        throw new Error(`OpenRouter API error ${response.status}: ${text}`);
+      }
+
+      const data = await response.json();
+      const content = data.choices?.[0]?.message?.content;
+      if (!content) {
+        throw new Error('No content in OpenRouter response');
+      }
+
+      return {
+        text: content.trim(),
+        model,
+        fallback: model !== chain[0],
+        durationMs: Date.now() - startTotal,
+        errors: errors.length > 0 ? errors : undefined
+      };
+    } catch (err) {
+      errors.push({ model, error: err.message, durationMs: Date.now() - startModel });
+      console.error(`OpenRouter ${model} failed (${Date.now() - startModel}ms): ${err.message}`);
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+
+  const err = new Error(`All models failed: ${errors.map((e) => `${e.model}: ${e.error}`).join('; ')}`);
+  err.modelErrors = errors;
+  err.durationMs = Date.now() - startTotal;
+  throw err;
+}
+
+export const CYCLE_SUMMARY_PROMPT = `You are a strength coach reviewing a trainee's completed training cycle (typically one week). Write 3-4 short paragraphs separated by blank lines.
 
 Your job is to give a cycle-level review — not a session-by-session recap. The app already shows set completion rate, individual session breakdowns, and deload adjustments — do NOT repeat any of that. Synthesize across the cycle.
 
+The data tells the story — your job is to interpret it honestly, not to make the trainee feel good.
+
 Cover these in order of relevance (skip any that don't apply):
 1. Overall cycle assessment: was this a build/deload/peak week? Did volume and intensity match the intent? If it was a deload, don't flag low numbers as a problem.
 2. Progression commentary: the app made auto-progression decisions listed below. Comment on whether they look right given the data.
@@ -15,61 +85,24 @@ Cover these in order of relevance (skip any that don't apply):
 4. Goal progress: if the trainee has strength goals, comment on trajectory.
 5. One concrete thing to watch or change next cycle. Be specific.
 
-Rules:
-- Only state what the data shows. Never claim how something "felt."
-- Reference specific exercises, weights, and reps. Use numbers, not vague praise.
-- If there are PRs, mention them matter-of-factly. Do not celebrate or inflate them.
-- If exercises were swapped from the plan, note the pattern and ask about it if recurring.
-- Write like a training partner looking at a logbook, not a motivational coach. Short sentences, no filler, no cheerleading. Questions are good.
-- Never use words like: impressive, crushed, solid, demonstrating, significant, incredible, fantastic, highlighting, smooth, controlled.
-- Never use -ing clauses that add fake depth.
-- No bullet points or lists.`;
+Only state what the data shows. Never claim how something "felt." Reference specific exercises, weights, and reps — use numbers, not vague descriptions. If there are PRs, mention them matter-of-factly. If exercises were swapped from the plan, note the pattern and ask about it if recurring. Write like a training partner looking at a logbook. Short sentences, no filler, no cheerleading. Questions are good.
 
-export async function generateCoachingSummary(cycleContext, { apiKey, model, timeoutMs } = {}) {
-  const resolvedModel = model || DEFAULT_MODEL;
-  const resolvedTimeout = timeoutMs || DEFAULT_TIMEOUT_MS;
-
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), resolvedTimeout);
-
-  try {
-    const userContent = formatCycleContext(cycleContext);
-
-    const response = await fetch('https://openrouter.ai/api/v1/chat/completions', {
-      method: 'POST',
-      headers: {
-        'Authorization': `Bearer ${apiKey}`,
-        'Content-Type': 'application/json',
-        'HTTP-Referer': 'https://incremnt.app',
-        'X-Title': 'incremnt'
-      },
-      body: JSON.stringify({
-        model: resolvedModel,
-        messages: [
-          { role: 'system', content: CYCLE_SUMMARY_PROMPT },
-          { role: 'user', content: userContent }
-        ],
-        max_tokens: DEFAULT_MAX_TOKENS,
-        temperature: 0.7
-      }),
-      signal: controller.signal
-    });
-
-    if (!response.ok) {
-      const text = await response.text().catch(() => '');
-      throw new Error(`OpenRouter API error ${response.status}: ${text}`);
-    }
+If you catch yourself writing something that sounds like a performance review or a fitness influencer post, rewrite it. No -ing clauses that add fake depth. No bullet points or lists.`;
 
-    const data = await response.json();
-    const content = data.choices?.[0]?.message?.content;
-    if (!content) {
-      throw new Error('No content in OpenRouter response');
+export async function generateCoachingSummary(cycleContext, { apiKey, model, timeoutMs } = {}) {
+  const userContent = formatCycleContext(cycleContext);
+  return callOpenRouter(
+    [
+      { role: 'system', content: CYCLE_SUMMARY_PROMPT },
+      { role: 'user', content: userContent }
+    ],
+    {
+      apiKey,
+      models: model ? [model] : SUMMARY_MODEL_CHAIN,
+      temperature: 0.5,
+      timeoutMs
     }
-
-    return content.trim();
-  } finally {
-    clearTimeout(timer);
-  }
+  );
 }
 
 export function formatCycleContext(ctx) {
@@ -163,77 +196,60 @@ export function formatCycleContext(ctx) {
     }
   }
 
+  const recoveryParts = [];
+  if (ctx.avgRestingHR) recoveryParts.push(`avg resting HR ${ctx.avgRestingHR} bpm`);
+  if (ctx.avgHRV) recoveryParts.push(`avg HRV ${ctx.avgHRV} ms`);
+  if (ctx.latestVO2Max) recoveryParts.push(`VO2 max ${ctx.latestVO2Max} ml/kg/min`);
+  if (ctx.avgSleepMins) recoveryParts.push(`avg sleep ${(ctx.avgSleepMins / 60).toFixed(1)}h`);
+  if (ctx.latestBodyWeightKg) recoveryParts.push(`body weight ${ctx.latestBodyWeightKg} kg`);
+  if (recoveryParts.length > 0) {
+    lines.push('');
+    lines.push(`Recovery metrics this cycle: ${recoveryParts.join(', ')}`);
+  }
+
+  if (ctx.cycleCardio?.length > 0) {
+    lines.push('');
+    lines.push('Cardio this cycle:');
+    for (const w of ctx.cycleCardio) {
+      const parts = [w.durationSecs ? `${Math.round(w.durationSecs / 60)} min` : '? min'];
+      if (w.distanceKm) parts.push(`${w.distanceKm.toFixed(1)} km`);
+      if (w.avgHR) parts.push(`avg HR ${w.avgHR} bpm`);
+      if (w.effortScore) parts.push(`effort ${w.effortScore}/10`);
+      lines.push(`  ${w.date} ${w.workoutType}: ${parts.join(', ')}`);
+    }
+  }
+
   return lines.join('\n');
 }
 
 export const WORKOUT_COACH_PROMPT = `You are reviewing a training session log. Write 2-3 short paragraphs separated by blank lines.
 
-Your job is to surface things the user wouldn't notice from glancing at their workout summary. The app already shows them PRs, total volume, effort score, and exercise breakdown — do NOT repeat any of that.
-
-Focus on:
-- Plan deviations: exercises swapped, skipped, or added vs the plan. Ask why if something looks unusual.
-- Set completion: if they did fewer sets than planned on an exercise, note it and ask about it.
-- Cross-session patterns: trends across recent sessions (volume direction on specific lifts, consistent cutoffs, same weight for weeks).
-- If exercises are marked "first session" they have zero prior history. State this plainly — don't frame it as "exploring" or "a new loading strategy."
-- If this is an adhoc session (no program), note any overlap with programmed exercises.
-- Ask 1-2 genuine questions about choices that look interesting or unusual.
-
-Voice rules — follow these exactly:
-- Only state what the data shows. Never claim how something "felt."
-- Be specific. Use numbers and exercise names, not vague descriptions.
-- No hedging: don't soften with "suggests", "appears to", "looks like", "seems", "might", "could potentially", "may want to." State it.
-- No filler preambles: don't start sentences with "The session shows", "Your performance indicates", "It's worth noting." Just say it.
-- No -ing clauses that add fake depth ("indicating progressive overload", "demonstrating strength gains", "suggesting increased capacity").
-- Never use: impressive, crushed, solid, demonstrating, significant, incredible, fantastic, smooth, controlled, highlighting, journey, empower.
-- Never restate PRs, total volume, or effort score — the user already sees these.
-- Write like a training partner reading a logbook. Short sentences, no filler, no cheerleading.
-- No bullet points or lists.`;
+Your job is to surface things the user wouldn't notice from glancing at their workout summary. The app already shows them PRs, total volume, effort score, and exercise breakdown — do NOT repeat any of that. The data tells the story — your job is to interpret it honestly, not to make the user feel good.
 
-export async function generateWorkoutCoachingSummary(workoutContext, { apiKey, model, timeoutMs } = {}) {
-  const resolvedModel = model || DEFAULT_MODEL;
-  const resolvedTimeout = timeoutMs || DEFAULT_TIMEOUT_MS;
-
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), resolvedTimeout);
-
-  try {
-    const userContent = formatWorkoutContext(workoutContext);
-
-    const response = await fetch('https://openrouter.ai/api/v1/chat/completions', {
-      method: 'POST',
-      headers: {
-        'Authorization': `Bearer ${apiKey}`,
-        'Content-Type': 'application/json',
-        'HTTP-Referer': 'https://incremnt.app',
-        'X-Title': 'incremnt'
-      },
-      body: JSON.stringify({
-        model: resolvedModel,
-        messages: [
-          { role: 'system', content: WORKOUT_COACH_PROMPT },
-          { role: 'user', content: userContent }
-        ],
-        max_tokens: DEFAULT_MAX_TOKENS,
-        temperature: 0.7
-      }),
-      signal: controller.signal
-    });
-
-    if (!response.ok) {
-      const text = await response.text().catch(() => '');
-      throw new Error(`OpenRouter API error ${response.status}: ${text}`);
-    }
+Focus on plan deviations (exercises swapped, skipped, or added vs the plan), set completion (if they did fewer sets than planned, note it and ask about it), and cross-session patterns (volume direction on specific lifts, consistent cutoffs, same weight for weeks). If exercises are marked "first session" they have zero prior history — state this plainly, don't frame it as "exploring" or "a new loading strategy." If this is an adhoc session, note any overlap with programmed exercises.
 
-    const data = await response.json();
-    const content = data.choices?.[0]?.message?.content;
-    if (!content) {
-      throw new Error('No content in OpenRouter response');
-    }
+Never name an exercise that does not appear in the workout data below. [first session] means no prior history for that exact exercise. It does not mean the user switched from another exercise.
 
-    return content.trim();
-  } finally {
-    clearTimeout(timer);
-  }
+Ask 1-2 genuine questions about choices that look interesting or unusual. This is the most valuable thing you can do — a good question is worth more than restating what happened.
+
+Only state what the data shows. Never claim how something "felt." Be specific — use numbers and exercise names. Don't soften with "suggests", "appears to", "seems", "might." State it. Don't start sentences with "The session shows", "Your performance indicates", "It's worth noting." Just say it.
+
+If you catch yourself writing something that sounds like a performance review or a fitness influencer post, rewrite it. No -ing clauses that add fake depth. No bullet points or lists.`;
+
+export async function generateWorkoutCoachingSummary(workoutContext, { apiKey, model, timeoutMs } = {}) {
+  const userContent = formatWorkoutContext(workoutContext);
+  return callOpenRouter(
+    [
+      { role: 'system', content: WORKOUT_COACH_PROMPT },
+      { role: 'user', content: userContent }
+    ],
+    {
+      apiKey,
+      models: model ? [model] : SUMMARY_MODEL_CHAIN,
+      temperature: 0.5,
+      timeoutMs
+    }
+  );
 }
 
 export function formatWorkoutContext(ctx) {
@@ -290,54 +306,66 @@ export function formatWorkoutContext(ctx) {
     }
   }
 
-  return lines.join('\n');
-}
+  // Recovery context
+  const recoveryParts = [];
+  if (ctx.restingHROnDay) recoveryParts.push(`resting HR ${Math.round(ctx.restingHROnDay)} bpm`);
+  if (ctx.hrvOnDay) recoveryParts.push(`HRV ${Math.round(ctx.hrvOnDay)} ms`);
+  if (ctx.vo2MaxLatest) recoveryParts.push(`VO2 max ${ctx.vo2MaxLatest} ml/kg/min`);
+  if (ctx.sleepNight) recoveryParts.push(`sleep ${(ctx.sleepNight.durationMins / 60).toFixed(1)}h`);
+  if (ctx.bodyWeightKg) recoveryParts.push(`body weight ${ctx.bodyWeightKg} kg`);
+  if (recoveryParts.length > 0) {
+    lines.push(`Recovery (session day): ${recoveryParts.join(', ')}`);
+  }
 
-const ASK_PROMPT = `You are a knowledgeable strength training assistant. Answer questions about the user's workout history concisely. Reference specific numbers, dates, and exercises from their data. If the data doesn't contain information to answer the question, say so briefly. Keep answers to 2-4 sentences.`;
-
-export async function generateAskAnswer(context, question, { apiKey, model, timeoutMs } = {}) {
-  const resolvedModel = model || DEFAULT_MODEL;
-  const resolvedTimeout = timeoutMs || DEFAULT_TIMEOUT_MS;
-
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), resolvedTimeout);
-
-  try {
-    const userContent = `${context}\n\nQuestion: ${question}`;
-
-    const response = await fetch('https://openrouter.ai/api/v1/chat/completions', {
-      method: 'POST',
-      headers: {
-        'Authorization': `Bearer ${apiKey}`,
-        'Content-Type': 'application/json',
-        'HTTP-Referer': 'https://incremnt.app',
-        'X-Title': 'incremnt'
-      },
-      body: JSON.stringify({
-        model: resolvedModel,
-        messages: [
-          { role: 'system', content: ASK_PROMPT },
-          { role: 'user', content: userContent }
-        ],
-        max_tokens: 300,
-        temperature: 0.3
-      }),
-      signal: controller.signal
-    });
-
-    if (!response.ok) {
-      const text = await response.text().catch(() => '');
-      throw new Error(`OpenRouter API error ${response.status}: ${text}`);
+  if (ctx.nearbyCardio?.length > 0) {
+    lines.push('Cardio in the 7 days before this session:');
+    for (const w of ctx.nearbyCardio) {
+      const parts = [w.durationSecs ? `${Math.round(w.durationSecs / 60)} min` : '? min'];
+      if (w.distanceKm) parts.push(`${w.distanceKm.toFixed(1)} km`);
+      if (w.avgHR) parts.push(`avg HR ${w.avgHR} bpm`);
+      if (w.effortScore) parts.push(`effort ${w.effortScore}/10`);
+      lines.push(`  ${w.date} ${w.workoutType}: ${parts.join(', ')}`);
     }
+  }
 
-    const data = await response.json();
-    const content = data.choices?.[0]?.message?.content;
-    if (!content) {
-      throw new Error('No content in OpenRouter response');
-    }
+  return lines.join('\n');
+}
+
+export const ASK_PROMPT = `You are a strength coach answering questions from the user's training history. Give concrete, useful coaching, not hype.
 
-    return content.trim();
-  } finally {
-    clearTimeout(timer);
+Rules:
+- Use only the data provided. If the data does not support a claim, do not make it.
+- Focus on trend, weak points, tradeoffs, and next steps. Be specific with exercises, weights, reps, volume, and timing when relevant.
+- Match the response length to the question. Short or playful prompts get a short conversational reply plus an invitation to ask something specific.
+- Keep the tone natural and direct. No hype, no filler, no emoji, no "let's dive in", no performance-review language.
+- Never name an exercise that does not appear in the training data below.
+- If data is missing or ambiguous, say so plainly.
+
+When the user asks for analysis, answer like a coach who has watched their training over time. When they ask for a plan, give a clear next-session recommendation. Bullet points are fine when they make the answer easier to use.`;
+
+export async function generateAskAnswer(context, question, { apiKey, model, timeoutMs, history = [] } = {}) {
+  // First user message includes the workout context; follow-ups are plain questions
+  const firstUserContent = `${context}\n\nQuestion: ${question}`;
+  const isFollowUp = history.length > 0;
+  const newUserContent = isFollowUp ? question : firstUserContent;
+
+  const priorMessages = history.map((m) => ({ role: m.role, content: m.content }));
+  // Prepend context to the first user message in history if needed
+  if (isFollowUp && priorMessages.length > 0 && priorMessages[0].role === 'user') {
+    priorMessages[0] = { role: 'user', content: `${context}\n\nQuestion: ${priorMessages[0].content}` };
   }
+
+  return callOpenRouter(
+    [
+      { role: 'system', content: ASK_PROMPT },
+      ...priorMessages,
+      { role: 'user', content: newUserContent }
+    ],
+    {
+      apiKey,
+      models: model ? [model] : ASK_MODEL_CHAIN,
+      temperature: 0.3,
+      timeoutMs: timeoutMs ?? ASK_TIMEOUT_MS
+    }
+  );
 }

package/src/queries.js

@@ -58,7 +58,8 @@ function sessionSummary(session) {
     recommendations: session.recommendations ?? {},
     historicalContext: session.historicalContext ?? null,
     prescriptionSnapshot: session.prescriptionSnapshot ?? null,
-    aiCoachNotes: session.summary?.aiCoachNotes ?? null
+    aiCoachNotes: session.summary?.aiCoachNotes ?? null,
+    aiCoachModel: session.summary?.aiCoachModel ?? null
   };
 }
 
@@ -648,6 +649,39 @@ export function cycleSummaryContext(snapshot, programId) {
     ? { completed: matchingSummary.totalSetsCompleted ?? 0, planned: matchingSummary.totalSetsPlanned ?? 0 }
     : null;
 
+  // Health metrics spanning the cycle
+  const cycleStart = String(cycleSessions[0] ? completionDateForSession(cycleSessions[0]) : '');
+  const cycleEnd = String(cycleSessions[cycleSessions.length - 1]
+    ? completionDateForSession(cycleSessions[cycleSessions.length - 1]) : '');
+  const cycleCardio = (snapshot.healthMetrics?.otherWorkouts ?? [])
+    .filter((w) => w.date >= cycleStart && w.date <= cycleEnd);
+  const cycleRestingHR = (snapshot.healthMetrics?.restingHR ?? [])
+    .filter((m) => m.date >= cycleStart && m.date <= cycleEnd);
+  const cycleHRV = (snapshot.healthMetrics?.hrv ?? [])
+    .filter((m) => m.date >= cycleStart && m.date <= cycleEnd);
+  const cycleVO2Max = (snapshot.healthMetrics?.vo2Max ?? [])
+    .filter((m) => m.date >= cycleStart && m.date <= cycleEnd);
+  const cycleSleep = (snapshot.healthMetrics?.sleep ?? [])
+    .filter((m) => m.date >= cycleStart && m.date <= cycleEnd);
+
+  const avgRestingHR = cycleRestingHR.length > 0
+    ? Math.round(cycleRestingHR.reduce((s, m) => s + m.value, 0) / cycleRestingHR.length)
+    : null;
+  const avgHRV = cycleHRV.length > 0
+    ? Math.round(cycleHRV.reduce((s, m) => s + m.value, 0) / cycleHRV.length)
+    : null;
+  const latestVO2Max = cycleVO2Max.length > 0
+    ? Math.round(cycleVO2Max.at(-1).value * 10) / 10
+    : null;
+  const avgSleepMins = cycleSleep.length > 0
+    ? Math.round(cycleSleep.reduce((s, m) => s + m.durationMins, 0) / cycleSleep.length)
+    : null;
+  const cycleBodyWeight = (snapshot.healthMetrics?.bodyWeight ?? [])
+    .filter((m) => m.date >= cycleStart && m.date <= cycleEnd);
+  const latestBodyWeightKg = cycleBodyWeight.length > 0
+    ? Math.round(cycleBodyWeight.at(-1).value * 10) / 10
+    : null;
+
   return {
     programName: program.name,
     cycleNumber: cycleWeekNumber,
@@ -661,7 +695,13 @@ export function cycleSummaryContext(snapshot, programId) {
     cycleIntent,
     adaptationNote,
     previousCycles,
-    exerciseTrends
+    exerciseTrends,
+    cycleCardio: cycleCardio.length > 0 ? cycleCardio : null,
+    avgRestingHR,
+    avgHRV,
+    latestVO2Max,
+    avgSleepMins,
+    latestBodyWeightKg
   };
 }
 
@@ -772,6 +812,31 @@ export function workoutSummaryContext(snapshot, sessionId) {
   }
 
   const isAdhoc = !session.programId;
+
+  // Include other workouts from the 7 days before this session for coach context
+  const sessionDateStr = String(sessionDate);
+  const weekBefore = new Date(new Date(sessionDateStr).getTime() - 7 * 24 * 60 * 60 * 1000)
+    .toISOString().slice(0, 10);
+  const nearbyCardio = (snapshot.healthMetrics?.otherWorkouts ?? [])
+    .filter((w) => w.date >= weekBefore && w.date <= sessionDateStr);
+
+  const restingHROnDay = (snapshot.healthMetrics?.restingHR ?? [])
+    .find((m) => m.date === sessionDateStr);
+  const hrvOnDay = (snapshot.healthMetrics?.hrv ?? [])
+    .find((m) => m.date === sessionDateStr);
+  const sleepNight = (snapshot.healthMetrics?.sleep ?? [])
+    .find((m) => m.date === sessionDateStr);
+  const vo2MaxRecent = (snapshot.healthMetrics?.vo2Max ?? [])
+    .filter((m) => m.date >= weekBefore && m.date <= sessionDateStr);
+  const vo2MaxLatest = vo2MaxRecent.length > 0
+    ? Math.round(vo2MaxRecent.at(-1).value * 10) / 10
+    : null;
+  const bodyWeightOnDay = (snapshot.healthMetrics?.bodyWeight ?? [])
+    .find((m) => m.date === sessionDateStr);
+  const bodyWeightKg = bodyWeightOnDay
+    ? Math.round(bodyWeightOnDay.value * 10) / 10
+    : null;
+
   const result = {
     sessionDate,
     dayName,
@@ -781,7 +846,13 @@ export function workoutSummaryContext(snapshot, sessionId) {
     effortScore: session.summary?.effortScore ?? null,
     exercises,
     recentComparisons,
-    prs
+    prs,
+    nearbyCardio: nearbyCardio.length > 0 ? nearbyCardio : null,
+    restingHROnDay: restingHROnDay?.value ?? null,
+    hrvOnDay: hrvOnDay?.value ?? null,
+    vo2MaxLatest,
+    sleepNight: sleepNight ?? null,
+    bodyWeightKg
   };
   if (planComparison) result.planComparison = planComparison;
   return result;
@@ -863,9 +934,123 @@ export function askContext(snapshot) {
     }
   }
 
+  appendHealthMetricsContext(lines, snapshot.healthMetrics, { recentDays: 14 });
+
   return lines.join('\n');
 }
 
+function appendHealthMetricsContext(lines, metrics, { recentDays = 14 } = {}) {
+  if (!metrics) return;
+
+  const cutoff = new Date(Date.now() - recentDays * 24 * 60 * 60 * 1000).toISOString().slice(0, 10);
+
+  const recentWorkouts = (metrics.otherWorkouts ?? []).filter((w) => w.date >= cutoff);
+  if (recentWorkouts.length > 0) {
+    lines.push('');
+    lines.push(`Other workouts (last ${recentDays} days):`);
+    for (const w of recentWorkouts) {
+      const parts = [`${w.durationSecs ? Math.round(w.durationSecs / 60) : '?'} min`];
+      if (w.distanceKm) parts.push(`${w.distanceKm.toFixed(1)} km`);
+      if (w.avgHR) parts.push(`avg HR ${w.avgHR} bpm`);
+      if (w.calories) parts.push(`${w.calories} kcal`);
+      if (w.effortScore) parts.push(`effort ${w.effortScore}/10`);
+      lines.push(`  ${w.date} ${w.workoutType}: ${parts.join(', ')}`);
+    }
+  }
+
+  const recentRestingHR = (metrics.restingHR ?? []).filter((m) => m.date >= cutoff);
+  if (recentRestingHR.length > 0) {
+    const avg = Math.round(recentRestingHR.reduce((s, m) => s + m.value, 0) / recentRestingHR.length);
+    const latest = recentRestingHR[recentRestingHR.length - 1];
+    lines.push('');
+    lines.push(`Resting HR (last ${recentDays} days): avg ${avg} bpm, latest ${Math.round(latest.value)} bpm (${latest.date})`);
+  }
+
+  const recentHRV = (metrics.hrv ?? []).filter((m) => m.date >= cutoff);
+  if (recentHRV.length > 0) {
+    const avg = Math.round(recentHRV.reduce((s, m) => s + m.value, 0) / recentHRV.length);
+    const latest = recentHRV[recentHRV.length - 1];
+    lines.push(`HRV (last ${recentDays} days): avg ${avg} ms, latest ${Math.round(latest.value)} ms (${latest.date})`);
+  }
+
+  const recentVO2Max = (metrics.vo2Max ?? []).filter((m) => m.date >= cutoff);
+  if (recentVO2Max.length > 0) {
+    const latest = recentVO2Max[recentVO2Max.length - 1];
+    lines.push(`VO2 Max: ${Math.round(latest.value * 10) / 10} ml/kg/min (${latest.date})`);
+  }
+
+  const recentSleep = (metrics.sleep ?? []).filter((m) => m.date >= cutoff);
+  if (recentSleep.length > 0) {
+    const avgMins = Math.round(recentSleep.reduce((s, m) => s + m.durationMins, 0) / recentSleep.length);
+    const avgHours = (avgMins / 60).toFixed(1);
+    lines.push(`Sleep (last ${recentDays} days): avg ${avgHours}h/night`);
+  }
+
+  const recentBodyWeight = (metrics.bodyWeight ?? []).filter((m) => m.date >= cutoff);
+  if (recentBodyWeight.length > 0) {
+    const latest = recentBodyWeight[recentBodyWeight.length - 1];
+    const earliest = recentBodyWeight[0];
+    const delta = (latest.value - earliest.value).toFixed(1);
+    const trend = delta > 0 ? `+${delta}` : delta;
+    lines.push(`Body weight (last ${recentDays} days): latest ${latest.value.toFixed(1)} kg (${latest.date}), ${recentBodyWeight.length} readings, trend ${trend} kg`);
+  }
+}
+
+function healthSummary(snapshot, days = 14) {
+  const metrics = snapshot.healthMetrics;
+  if (!metrics) return { available: false };
+
+  const cutoff = new Date(Date.now() - days * 24 * 60 * 60 * 1000).toISOString().slice(0, 10);
+
+  const recentWorkouts = (metrics.otherWorkouts ?? []).filter((w) => w.date >= cutoff);
+  const recentRestingHR = (metrics.restingHR ?? []).filter((m) => m.date >= cutoff);
+  const recentHRV = (metrics.hrv ?? []).filter((m) => m.date >= cutoff);
+  const recentVO2Max = (metrics.vo2Max ?? []).filter((m) => m.date >= cutoff);
+  const recentSleep = (metrics.sleep ?? []).filter((m) => m.date >= cutoff);
+
+  const avg = (arr) => arr.length > 0 ? arr.reduce((s, m) => s + m.value, 0) / arr.length : null;
+
+  return {
+    available: true,
+    days,
+    cardio: recentWorkouts.map((w) => ({
+      date: w.date,
+      workoutType: w.workoutType,
+      durationMins: w.durationSecs ? Math.round(w.durationSecs / 60) : null,
+      distanceKm: w.distanceKm ?? null,
+      avgHR: w.avgHR ?? null,
+      calories: w.calories ?? null
+    })),
+    restingHR: {
+      avg: recentRestingHR.length > 0 ? Math.round(avg(recentRestingHR)) : null,
+      latest: recentRestingHR.length > 0 ? { value: Math.round(recentRestingHR.at(-1).value), date: recentRestingHR.at(-1).date } : null,
+      readings: recentRestingHR.length
+    },
+    hrv: {
+      avg: recentHRV.length > 0 ? Math.round(avg(recentHRV)) : null,
+      latest: recentHRV.length > 0 ? { value: Math.round(recentHRV.at(-1).value), date: recentHRV.at(-1).date } : null,
+      readings: recentHRV.length
+    },
+    vo2Max: {
+      latest: recentVO2Max.length > 0 ? { value: Math.round(recentVO2Max.at(-1).value * 10) / 10, date: recentVO2Max.at(-1).date } : null,
+      readings: recentVO2Max.length
+    },
+    sleep: {
+      avgHours: recentSleep.length > 0 ? Math.round(recentSleep.reduce((s, m) => s + m.durationMins, 0) / recentSleep.length / 60 * 10) / 10 : null,
+      nights: recentSleep.length
+    },
+    bodyWeight: (() => {
+      const recent = (metrics.bodyWeight ?? []).filter((m) => m.date >= cutoff);
+      if (recent.length === 0) return { latest: null, readings: 0 };
+      return {
+        latest: { value: Math.round(recent.at(-1).value * 10) / 10, date: recent.at(-1).date },
+        trend: Math.round((recent.at(-1).value - recent[0].value) * 10) / 10,
+        readings: recent.length
+      };
+    })()
+  };
+}
+
 function requiredOption(options, primaryKey, legacyKey = null) {
   return options[primaryKey] ?? (legacyKey ? options[legacyKey] : undefined);
 }
@@ -987,5 +1172,10 @@ export function executeReadCommand(snapshot, normalizedCommand, options = {}) {
     return { ok: true, payload };
   }
 
+  if (normalizedCommand === 'health-summary') {
+    const days = Number.parseInt(options.days ?? '14', 10);
+    return { ok: true, payload: healthSummary(snapshot, Number.isNaN(days) ? 14 : days) };
+  }
+
   return { ok: false, error: `Unknown read command: ${normalizedCommand}` };
 }

package/src/remote.js

@@ -29,10 +29,15 @@ const remoteCommandHandlers = {
   'program-list': executeRemoteRead,
   'program-summary': executeRemoteRead,
   'program-detail': executeRemoteRead,
+  'cycle-summary-list': executeRemoteRead,
+  'cycle-summary-show': executeRemoteRead,
   'planned-vs-actual': executeRemoteRead,
   'why-did-this-change': executeRemoteRead,
   'goals-list': executeRemoteRead,
-  'goals-show': executeRemoteRead
+  'goals-show': executeRemoteRead,
+  'health-summary': executeRemoteRead,
+  'ask-history': executeRemoteRead,
+  'ask-show': executeRemoteRead
 };
 
 async function executeRemoteRead(options, sessionState, normalizedCommand) {
@@ -111,6 +116,15 @@ function endpointForCommand(baseUrl, normalizedCommand, options) {
       return resolveServiceUrl(baseUrl, '/cli/programs/current');
     case 'program-detail':
       return resolveServiceUrl(baseUrl, options.id ? `/cli/programs/${options.id}` : '/cli/programs/active');
+    case 'cycle-summary-list': {
+      const cyclesUrl = resolveServiceUrl(baseUrl, '/cli/cycles');
+      if (options['program-id']) {
+        cyclesUrl.searchParams.set('program-id', options['program-id']);
+      }
+      return cyclesUrl;
+    }
+    case 'cycle-summary-show':
+      return resolveServiceUrl(baseUrl, `/cli/cycles/${options.id}`);
     case 'exercise-history': {
       const historyUrl = resolveServiceUrl(baseUrl, '/cli/exercises/history');
       historyUrl.searchParams.set('name', options.name ?? options.exercise);
@@ -122,6 +136,22 @@ function endpointForCommand(baseUrl, normalizedCommand, options) {
       return resolveServiceUrl(baseUrl, '/cli/goals');
     case 'goals-show':
       return resolveServiceUrl(baseUrl, options.id ? `/cli/goals/${options.id}` : '/cli/goals');
+    case 'health-summary': {
+      const healthUrl = resolveServiceUrl(baseUrl, '/cli/health/summary');
+      if (options.days) {
+        healthUrl.searchParams.set('days', options.days);
+      }
+      return healthUrl;
+    }
+    case 'ask-history': {
+      const askUrl = resolveServiceUrl(baseUrl, '/cli/ask/history');
+      if (options.limit) {
+        askUrl.searchParams.set('limit', options.limit);
+      }
+      return askUrl;
+    }
+    case 'ask-show':
+      return resolveServiceUrl(baseUrl, `/cli/ask/history/${options.id}`);
     default:
       return resolveServiceUrl(baseUrl, '/');
   }
@@ -136,6 +166,14 @@ function resourceNotFoundMessage(normalizedCommand, options) {
     return `Session not found: ${options['session-id']}`;
   }
 
+  if (normalizedCommand === 'cycle-summary-show') {
+    return `Cycle summary not found: ${options.id}`;
+  }
+
+  if (normalizedCommand === 'ask-show') {
+    return `Conversation not found: ${options.id}`;
+  }
+
   return 'Requested resource was not found.';
 }
 

package/src/sync-service.js

@@ -4,6 +4,7 @@ import { executeReadCommand } from './queries.js';
 
 const MAX_BODY_BYTES = 10 * 1024 * 1024; // 10 MB
 const DEFAULT_RATE_LIMIT_WINDOW_MS = 60_000;
+const MAX_ASK_USER_TURNS = 3;
 const DEFAULT_RATE_LIMIT_RULES = {
   'workout-summary-ai': 3,
   'cycle-summary-ai': 3,
@@ -30,6 +31,14 @@ function json(response, statusCode, payload) {
   response.end(JSON.stringify(payload));
 }
 
+function jsonWithHeaders(response, statusCode, payload, headers = {}) {
+  response.writeHead(statusCode, {
+    'content-type': 'application/json',
+    ...headers
+  });
+  response.end(JSON.stringify(payload));
+}
+
 function logRequest(request, statusCode, extra = '') {
   const method = request.method ?? '?';
   const rawUrl = request.url ?? '/';
@@ -55,8 +64,9 @@ function methodNotAllowed(response, message = 'Method not allowed') {
   json(response, 405, { error: message });
 }
 
-function internalError(response, error) {
+function internalError(response, error, onError) {
   console.error('Internal error:', error.message);
+  if (onError) onError(error);
   json(response, 500, { error: 'Internal server error' });
 }
 
@@ -120,16 +130,22 @@ function createRateLimiter({
 
       if (!bucket || bucket.resetAt <= now) {
         buckets.set(key, { count: 1, resetAt: now + windowMs });
-        return { allowed: true };
+        return { allowed: true, retryAfterSec: Math.ceil(windowMs / 1000) };
       }
 
       if (bucket.count >= limit) {
-        return { allowed: false };
+        return {
+          allowed: false,
+          retryAfterSec: Math.max(1, Math.ceil((bucket.resetAt - now) / 1000))
+        };
       }
 
       bucket.count += 1;
       buckets.set(key, bucket);
-      return { allowed: true };
+      return {
+        allowed: true,
+        retryAfterSec: Math.max(1, Math.ceil((bucket.resetAt - now) / 1000))
+      };
     }
   };
 }
@@ -329,7 +345,23 @@ function routeRequest(url) {
   }
 
   if (pathname === '/cli/ask/history') {
-    return { command: 'ask-history', options: {} };
+    return { command: 'ask-history', options: { limit: url.searchParams.get('limit') ?? undefined } };
+  }
+
+  {
+    const askShowMatch = pathname.match(/^\/cli\/ask\/history\/(.+)$/);
+    if (askShowMatch) {
+      return { command: 'ask-show', options: { id: askShowMatch[1] } };
+    }
+  }
+
+  if (pathname === '/cli/health/summary') {
+    return {
+      command: 'health-summary',
+      options: {
+        days: url.searchParams.get('days') ?? undefined
+      }
+    };
   }
 
   return null;
@@ -804,7 +836,8 @@ export function createSyncServiceRequestHandler({
   updateProposalForAccount = null,
   updateAnalysisConsentForAccount = null,
   saveAskConversationForAccount = null,
-  listAskConversationsForAccount = null
+  listAskConversationsForAccount = null,
+  onError = null
 }) {
   const rateLimiter = createRateLimiter(rateLimitConfig ?? {});
 
@@ -841,8 +874,14 @@ export function createSyncServiceRequestHandler({
         return;
       }
 
-      if (!rateLimiter.check(request, route.command).allowed) {
-        json(response, 429, { error: 'Too many requests' });
+      const rateLimitResult = rateLimiter.check(request, route.command);
+      if (!rateLimitResult.allowed) {
+        jsonWithHeaders(
+          response,
+          429,
+          { error: 'Too many requests', code: 'rate_limited' },
+          { 'Retry-After': String(rateLimitResult.retryAfterSec ?? 60) }
+        );
         return;
       }
 
@@ -1693,18 +1732,32 @@ export function createSyncServiceRequestHandler({
 
         const openrouterKey = process.env.OPENROUTER_API_KEY;
         if (!openrouterKey) {
-          json(response, 503, { error: 'AI summaries not configured' });
+          json(response, 503, { error: 'AI summaries not configured', code: 'not_configured' });
           return;
         }
 
         try {
           const { generateWorkoutCoachingSummary } = await import('./openrouter.js');
-          const model = process.env.OPENROUTER_MODEL || undefined;
-          const summary = await generateWorkoutCoachingSummary(ctx, { apiKey: openrouterKey, model });
-          json(response, 200, { summary });
+          const result = await generateWorkoutCoachingSummary(ctx, { apiKey: openrouterKey });
+          if (result.fallback && onError) {
+            const warning = new Error(`AI workout-summary used fallback model ${result.model}`);
+            warning.level = 'warning';
+            onError(warning, {
+              feature: 'workout-summary',
+              modelErrors: result.errors,
+              durationMs: result.durationMs,
+              fallbackModel: result.model
+            });
+          }
+          json(response, 200, { summary: result.text, model: result.model });
         } catch (err) {
           console.error('AI workout summary error:', err.message);
-          json(response, 502, { error: 'Failed to generate AI summary' });
+          onError?.(err, {
+            feature: 'workout-summary',
+            modelErrors: err.modelErrors,
+            durationMs: err.durationMs
+          });
+          json(response, 502, { error: 'Failed to generate AI summary', code: 'ai_unavailable' });
         }
         return;
       }
@@ -1725,18 +1778,32 @@ export function createSyncServiceRequestHandler({
 
         const openrouterKey = process.env.OPENROUTER_API_KEY;
         if (!openrouterKey) {
-          json(response, 503, { error: 'AI summaries not configured' });
+          json(response, 503, { error: 'AI summaries not configured', code: 'not_configured' });
           return;
         }
 
         try {
           const { generateCoachingSummary } = await import('./openrouter.js');
-          const model = process.env.OPENROUTER_MODEL || undefined;
-          const summary = await generateCoachingSummary(ctx, { apiKey: openrouterKey, model });
-          json(response, 200, { summary });
+          const result = await generateCoachingSummary(ctx, { apiKey: openrouterKey });
+          if (result.fallback && onError) {
+            const warning = new Error(`AI cycle-summary used fallback model ${result.model}`);
+            warning.level = 'warning';
+            onError(warning, {
+              feature: 'cycle-summary',
+              modelErrors: result.errors,
+              durationMs: result.durationMs,
+              fallbackModel: result.model
+            });
+          }
+          json(response, 200, { summary: result.text, model: result.model });
         } catch (err) {
           console.error('AI cycle summary error:', err.message);
-          json(response, 502, { error: 'Failed to generate AI summary' });
+          onError?.(err, {
+            feature: 'cycle-summary',
+            modelErrors: err.modelErrors,
+            durationMs: err.durationMs
+          });
+          json(response, 502, { error: 'Failed to generate AI summary', code: 'ai_unavailable' });
         }
         return;
       }
@@ -1765,9 +1832,29 @@ export function createSyncServiceRequestHandler({
           return;
         }
 
+        const conversationId = body?.conversationId;
+        if (!conversationId || typeof conversationId !== 'string') {
+          badRequest(response, 'conversationId is required');
+          return;
+        }
+
+        const history = Array.isArray(body?.history) ? body.history : [];
+        const validHistory = history.every(
+          (m) => m && typeof m.role === 'string' && typeof m.content === 'string'
+        );
+        if (!validHistory) {
+          badRequest(response, 'history must be an array of {role, content} objects');
+          return;
+        }
+        const priorUserTurns = history.filter((m) => m.role === 'user').length;
+        if (priorUserTurns >= MAX_ASK_USER_TURNS) {
+          json(response, 400, { error: `Ask Coach supports up to ${MAX_ASK_USER_TURNS} questions per conversation. Start a new conversation.`, code: 'conversation_limit' });
+          return;
+        }
+
         const openrouterKey = process.env.OPENROUTER_API_KEY;
         if (!openrouterKey) {
-          json(response, 503, { error: 'AI not configured' });
+          json(response, 503, { error: 'AI not configured', code: 'not_configured' });
           return;
         }
 
@@ -1776,19 +1863,42 @@ export function createSyncServiceRequestHandler({
 
         try {
           const { generateAskAnswer } = await import('./openrouter.js');
-          const model = process.env.OPENROUTER_MODEL || undefined;
-          const answer = await generateAskAnswer(ctx, question, { apiKey: openrouterKey, model });
+          const askResult = await generateAskAnswer(ctx, question, { apiKey: openrouterKey, history });
+          const updatedMessages = [
+            ...history,
+            { role: 'user', content: question },
+            { role: 'assistant', content: askResult.text }
+          ];
           if (saveAskConversationForAccount) {
             try {
-              await saveAskConversationForAccount(account, { question, answer });
+              await saveAskConversationForAccount(account, {
+                id: conversationId,
+                messages: updatedMessages,
+                model: askResult.model
+              });
             } catch (saveErr) {
               console.error('Failed to save ask conversation:', saveErr.message);
             }
           }
-          json(response, 200, { answer });
+          if (askResult.fallback && onError) {
+            const warning = new Error(`AI ask-coach used fallback model ${askResult.model}`);
+            warning.level = 'warning';
+            onError(warning, {
+              feature: 'ask-coach',
+              modelErrors: askResult.errors,
+              durationMs: askResult.durationMs,
+              fallbackModel: askResult.model
+            });
+          }
+          json(response, 200, { answer: askResult.text, model: askResult.model });
         } catch (err) {
           console.error('AI ask error:', err.message);
-          json(response, 502, { error: 'Failed to generate AI answer' });
+          onError?.(err, {
+            feature: 'ask-coach',
+            modelErrors: err.modelErrors,
+            durationMs: err.durationMs
+          });
+          json(response, 502, { error: 'Failed to generate AI answer', code: 'ai_unavailable' });
         }
         return;
       }
@@ -1805,8 +1915,15 @@ export function createSyncServiceRequestHandler({
         }
 
         try {
-          const conversations = await listAskConversationsForAccount(account);
-          json(response, 200, { conversations });
+          const limit = route.options.limit ? parseInt(route.options.limit, 10) : 20;
+          const conversations = await listAskConversationsForAccount(account, { limit });
+          const summaries = conversations.map((c) => ({
+            id: c.id,
+            preview: (c.messages?.[0]?.content ?? '').slice(0, 120),
+            messageCount: c.messages?.length ?? 0,
+            createdAt: c.createdAt
+          }));
+          json(response, 200, { conversations: summaries });
         } catch (err) {
           console.error('Ask history error:', err.message);
           json(response, 500, { error: 'Failed to load ask history' });
@@ -1814,6 +1931,32 @@ export function createSyncServiceRequestHandler({
         return;
       }
 
+      if (route.command === 'ask-show') {
+        if (request.method !== 'GET') {
+          methodNotAllowed(response, 'Use GET for /cli/ask/history/:id.');
+          return;
+        }
+
+        if (!listAskConversationsForAccount) {
+          json(response, 503, { error: 'Ask history not available' });
+          return;
+        }
+
+        try {
+          const conversations = await listAskConversationsForAccount(account);
+          const conversation = conversations.find((c) => c.id === route.options.id);
+          if (!conversation) {
+            notFound(response, `Conversation not found: ${route.options.id}`);
+            return;
+          }
+          json(response, 200, conversation);
+        } catch (err) {
+          console.error('Ask show error:', err.message);
+          json(response, 500, { error: 'Failed to load conversation' });
+        }
+        return;
+      }
+
       const result = executeReadCommand(snapshot, route.command, route.options);
       if (!result.ok) {
         if (result.error.startsWith('Session not found')) {
@@ -1827,7 +1970,7 @@ export function createSyncServiceRequestHandler({
 
       json(response, 200, result.payload);
     } catch (error) {
-      internalError(response, error);
+      internalError(response, error, onError);
     }
   };
 }