@gonzih/debate-coach 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Maksim Soltan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,250 @@
+# debate-coach
+
+> An MCP server that trains critical thinking by making students argue both sides of any topic, catching logical fallacies in real time, scoring argument quality, and teaching the difference between an opinion and a reasoned position.
+
+[![npm](https://img.shields.io/npm/v/@gonzih/debate-coach)](https://www.npmjs.com/package/@gonzih/debate-coach)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+---
+
+## The Dream
+
+A 16-year-old says *"I think social media should be banned for under 18s."*
+
+Instead of agreeing or disagreeing, the AI says: *"Interesting. Make your case — give me your 3 strongest arguments."*
+
+The student argues. The AI rates each argument:
+- *"Argument 1: solid (evidence-based)."*
+- *"Argument 2: weak (anecdotal, logical fallacy: hasty generalization)."*
+- *"Argument 3: strong."*
+
+Then: *"Now flip sides. Argue against your own position as convincingly as you can."*
+
+This is how lawyers are trained. This is how scientists think. This is how good citizens reason.
+
+---
+
+## What It Does
+
+### 1. Argument Quality Scoring (0–10 per argument)
+Each argument is scored on four dimensions:
+- **Evidence (0–3):** Factual backing — studies, data, expert consensus
+- **Logic (0–3):** Soundness — no fallacies, valid reasoning
+- **Relevance (0–2):** Does it actually support the proposition?
+- **Originality (0–2):** Nuanced insight vs. generic platitude
+
+### 2. Real-Time Logical Fallacy Detection
+Detects 20 logical fallacies including:
+- Ad hominem, straw man, false dichotomy
+- Slippery slope, hasty generalization, appeal to authority
+- Post hoc (correlation ≠ causation), cherry picking, and 12 more
+
+### 3. Steel-Manning
+After you argue your side, the AI presents the *strongest possible opposing argument* — not a strawman. This prepares you for the flip challenge and teaches genuine intellectual honesty.
+
+### 4. Mandatory Flip-Sides Exercise
+You must argue the *opposite* of your original position. This is the hardest and most valuable part. It teaches:
+- Epistemic humility
+- Understanding of opposing views
+- How to construct genuinely compelling arguments you disagree with
+
+### 5. 50+ Curated Debate Topics
+Categories: Social/Ethical, Science/Environment, Politics/Policy, Philosophy/Values, Technology, Historical, Economics, Health
+
+### 6. Progress Tracking
+- Fallacy rate over time: *"You used hasty generalization 8 times 3 weeks ago, 2 times this week"*
+- Average argument score trend
+- Topics breadth
+- Flip success rate
+
+---
+
+## Installation
+
+```bash
+npm install -g @gonzih/debate-coach
+```
+
+Or use with `npx`:
+```bash
+npx @gonzih/debate-coach
+```
+
+---
+
+## MCP Configuration
+
+Add to your Claude Desktop config (`~/Library/Application Support/Claude/claude_desktop_config.json`):
+
+```json
+{
+  "mcpServers": {
+    "debate-coach": {
+      "command": "npx",
+      "args": ["@gonzih/debate-coach"]
+    }
+  }
+}
+```
+
+Or if installed globally:
+```json
+{
+  "mcpServers": {
+    "debate-coach": {
+      "command": "debate-coach"
+    }
+  }
+}
+```
+
+---
+
+## MCP Tools
+
+### `start_debate`
+```
+start_debate({ profileId, topic?, position? })
+→ { proposition, sessionId, instructions }
+```
+Start a new debate session. The AI frames your topic as a proper debate proposition.
+
+### `submit_argument`
+```
+submit_argument({ sessionId, argument })
+→ { score, fallacies[], feedback, strengtheningSuggestion }
+```
+Submit an argument. Get scored on evidence/logic/relevance/originality and fallacy-checked.
+
+### `get_steelman`
+```
+get_steelman({ sessionId })
+→ { steelman, keyCounterArguments[] }
+```
+After 3+ PRO arguments: see the strongest possible case against your position.
+
+### `flip_sides`
+```
+flip_sides({ sessionId })
+→ { prompt, newPosition }
+```
+Switch to arguing the opposite side.
+
+### `complete_debate`
+```
+complete_debate({ sessionId })
+→ { synthesis, scores, fallaciesDetected }
+```
+Finalize the debate and receive a synthesis of both sides.
+
+### `build_argument`
+```
+build_argument({ sessionId, thought })
+→ { questions[], hint }
+```
+Argument Builder Mode: Socratic scaffolding for students who don't know where to start.
+
+### `get_topic_list`
+```
+get_topic_list({ category?, ageGroup?, difficulty? })
+→ Topic[]
+```
+Browse 50+ curated debate topics.
+
+### `get_progress`
+```
+get_progress({ profileId })
+→ { debatesCompleted, avgScore, fallacyTrend, improvementAreas, ... }
+```
+View progress over time.
+
+### `get_fallacy_guide`
+```
+get_fallacy_guide({ fallacyType? })
+→ Fallacy guide or specific fallacy detail
+```
+Learn about the 20 logical fallacies the system detects.
+
+---
+
+## Debate Flow
+
+```
+start_debate
+    ↓
+submit_argument  ×3-5  (PRO phase)
+    ↓
+get_steelman           (see opposing case)
+    ↓
+flip_sides             (switch positions)
+    ↓
+submit_argument  ×3-5  (CON phase)
+    ↓
+complete_debate        (synthesis + scoring)
+    ↓
+get_progress           (track improvement)
+```
+
+---
+
+## The Socratic Method Connection
+
+Socrates never stated opinions — he asked questions until his interlocutors discovered contradictions in their own positions. The *elenchus* (cross-examination) was designed not to teach facts but to develop the capacity for rigorous thinking.
+
+debate-coach uses the same approach: it doesn't tell you what to think, it forces you to *defend* what you think — and then defend the opposite.
+
+---
+
+## Debate Formats Supported Conceptually
+
+### Lincoln-Douglas (LD) Debate
+One-on-one. Values-focused. Emphasizes philosophical and ethical clash. Perfect for the philosophical and policy topics in the topic list.
+
+**Structure adapted here:** PRO arguments → Steel-man → CON arguments → Synthesis
+
+### Oxford-Style Debate
+Motion-based. Audience votes before and after. The Oxford format's key insight: you must be able to articulate *why* the other side is reasonable before you can effectively argue against it. This is exactly what the steel-man step provides.
+
+### Karl Popper Format
+Teams of three argue competing positions. Focus on cross-examination. The Karl Popper format explicitly teaches students to attack *the strongest version* of the opposition — which is the steel-manning principle.
+
+---
+
+## Classroom Integration Guide
+
+### Individual Practice
+Students use debate-coach independently to prepare for class discussions. The progress tracking helps teachers see who is improving.
+
+### Paired Debate Prep
+Two students start debates on the same topic but opposite sides. They compare their steel-mans — seeing how well each predicted the other's actual arguments.
+
+### Flipped Classroom
+Assign debate-coach sessions as homework. Class time is spent discussing: *"What surprised you when you had to argue the other side?"*
+
+### Formative Assessment
+Use `get_progress` to track:
+- Which fallacies students commit most
+- Score improvement over the term
+- Whether students attempt the flip challenge
+
+### Discussion Starter
+After completing a debate session, share the synthesis in class. Use it as a jumping-off point: *"The AI says the core tension here is X vs. Y — do you agree?"*
+
+---
+
+## Progress Data Storage
+
+Debate history is stored locally in `~/.debate-coach/debates.db` (SQLite). No data is sent to any server. API calls are made only to Anthropic's Claude API for AI-powered scoring and analysis.
+
+---
+
+## Requirements
+
+- Node.js 18+
+- `ANTHROPIC_API_KEY` environment variable
+
+---
+
+## License
+
+MIT © Gonzih

package/SKILL.md

@@ -0,0 +1,91 @@
+# debate-coach Skill Guide
+
+## What Is This?
+debate-coach is an MCP server that trains critical thinking through structured debate. It implements the Socratic method digitally: instead of telling you what to think, it forces you to defend what you think — and then defend the opposite.
+
+## Quick Start
+
+### 1. Start a Debate
+```
+Use the start_debate tool with:
+- profileId: "student_alice"
+- topic: "Social media should be banned for users under 18"
+```
+
+### 2. Submit Arguments (PRO side first)
+```
+Use submit_argument with your sessionId and each argument.
+Example: "Multiple peer-reviewed studies, including the Haidt/Twenge research,
+show strong correlations between heavy social media use and increased rates of
+anxiety and depression in adolescent girls."
+```
+
+### 3. Get the Steel-Man
+```
+After 3+ arguments, call get_steelman to see the strongest opposing case.
+This is essential preparation for the flip challenge.
+```
+
+### 4. Flip Sides
+```
+Call flip_sides to switch to arguing AGAINST your original position.
+This is the hardest and most valuable part.
+```
+
+### 5. Submit CON Arguments
+```
+Submit 3-5 arguments against the proposition using submit_argument.
+```
+
+### 6. Complete & Synthesize
+```
+Call complete_debate to receive your final synthesis and save progress.
+```
+
+## Argument Builder Mode (For Beginners)
+If you don't know where to start:
+```
+Call build_argument with:
+- sessionId: your session ID
+- thought: "I think social media is bad but I don't know why exactly"
+```
+You'll receive Socratic questions to develop your rough thought into a strong argument.
+
+## Browse Topics
+```
+Call get_topic_list to browse 50+ curated topics.
+Filter by category: social, science, policy, philosophy, technology, historical, economics, health
+Filter by difficulty: easy, medium, hard
+Filter by ageGroup: teens, general
+```
+
+## Track Progress
+```
+Call get_progress with your profileId to see:
+- Score improvement over time
+- Which logical fallacies you commit most
+- Flip success rate
+- Topics debated
+```
+
+## What Makes a Good Argument?
+A strong argument (7+/10) has:
+- **Specific evidence**: Not just "studies show" but "the 2019 Twenge et al. meta-analysis of..."
+- **Logical structure**: Premise → Reasoning → Conclusion with no gaps
+- **Relevance**: Directly addresses the proposition, not a tangent
+- **Nuance**: Goes beyond the obvious — acknowledge complexity
+
+## Common Mistakes to Avoid
+1. **Anecdotal evidence**: "My cousin tried X and it worked" — use systematic data
+2. **Hasty generalization**: "Three examples prove all cases" — be careful with scale
+3. **False dichotomy**: "Either we do X or catastrophe" — more options usually exist
+4. **Post hoc**: "A happened, then B happened, so A caused B" — correlation ≠ causation
+5. **Appeal to emotion**: Emotional language without supporting logic
+
+## Learning Outcomes
+After regular use of debate-coach, students develop:
+- Ability to construct evidence-based arguments
+- Recognition of logical fallacies in real-world discourse (news, politics, advertising)
+- Intellectual empathy — understanding why reasonable people disagree
+- Comfort arguing positions they personally disagree with
+- Awareness of their own cognitive biases

package/dist/claude.d.ts

@@ -0,0 +1,26 @@
+import type { ScoredArgument, DebateSession } from "./types.js";
+export declare function refineProposition(rawTopic: string): Promise<{
+    proposition: string;
+    explanation: string;
+}>;
+export declare function scoreArgument(params: {
+    proposition: string;
+    position: string;
+    argument: string;
+    previousArguments: string[];
+}): Promise<ScoredArgument>;
+export declare function generateSteelman(session: DebateSession): Promise<{
+    steelman: string;
+    keyCounterArguments: string[];
+}>;
+export declare function generateSynthesis(session: DebateSession): Promise<string>;
+export declare function scaffoldArgument(params: {
+    proposition: string;
+    position: string;
+    userThought: string;
+}): Promise<{
+    questions: string[];
+    hint: string;
+}>;
+export declare function formatScoredArgument(arg: ScoredArgument): string;
+//# sourceMappingURL=claude.d.ts.map

package/dist/claude.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude.d.ts","sourceRoot":"","sources":["../src/claude.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAGV,cAAc,EACd,aAAa,EACd,MAAM,YAAY,CAAC;AAOpB,wBAAsB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC;IACjE,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC,CA+BD;AAID,wBAAsB,aAAa,CAAC,MAAM,EAAE;IAC1C,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,iBAAiB,EAAE,MAAM,EAAE,CAAC;CAC7B,GAAG,OAAO,CAAC,cAAc,CAAC,CAyF1B;AAID,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC;IACtE,QAAQ,EAAE,MAAM,CAAC;IACjB,mBAAmB,EAAE,MAAM,EAAE,CAAC;CAC/B,CAAC,CAoDD;AAID,wBAAsB,iBAAiB,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,CA8D/E;AAID,wBAAsB,gBAAgB,CAAC,MAAM,EAAE;IAC7C,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;CACrB,GAAG,OAAO,CAAC;IACV,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC,CAkCD;AAID,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM,CAkChE"}

package/dist/claude.js

@@ -0,0 +1,285 @@
+import Anthropic from "@anthropic-ai/sdk";
+import { FALLACY_NAMES_FOR_PROMPT } from "./fallacies.js";
+const client = new Anthropic();
+const MODEL = "claude-opus-4-6";
+// ─── Proposition Refinement ────────────────────────────────────────────────
+export async function refineProposition(rawTopic) {
+    const response = await client.messages.create({
+        model: MODEL,
+        max_tokens: 1024,
+        messages: [
+            {
+                role: "user",
+                content: `You are a debate coach helping a student frame a debate topic as a proper proposition.
+
+The student's topic: "${rawTopic}"
+
+A good debate proposition:
+- Is a clear, specific statement (not a question)
+- Can be argued FOR or AGAINST
+- Is falsifiable and not purely subjective
+- Is stated in present tense: "X should/is/does..."
+
+Respond with a JSON object only:
+{
+  "proposition": "The refined, properly-stated proposition",
+  "explanation": "Brief explanation of why this framing works well for debate (1-2 sentences)"
+}`,
+            },
+        ],
+    });
+    const text = response.content.find(b => b.type === "text")?.text ?? "{}";
+    const jsonMatch = text.match(/\{[\s\S]*\}/);
+    if (!jsonMatch)
+        throw new Error("Failed to parse proposition from Claude");
+    return JSON.parse(jsonMatch[0]);
+}
+// ─── Argument Scoring ──────────────────────────────────────────────────────
+export async function scoreArgument(params) {
+    const previousContext = params.previousArguments.length > 0
+        ? `\nPrevious arguments made:\n${params.previousArguments.map((a, i) => `${i + 1}. ${a}`).join("\n")}`
+        : "";
+    const response = await client.messages.create({
+        model: MODEL,
+        max_tokens: 2048,
+        messages: [
+            {
+                role: "user",
+                content: `You are an expert debate coach and logician. Analyze this argument rigorously.
+
+PROPOSITION: "${params.proposition}"
+POSITION BEING ARGUED: ${params.position}
+${previousContext}
+
+NEW ARGUMENT TO ANALYZE:
+"${params.argument}"
+
+Score the argument on these criteria:
+- Evidence (0-3): Does it include factual backing? Studies, data, specific examples, expert consensus?
+  0 = pure opinion, 1 = vague reference, 2 = reasonable claim with some support, 3 = strong empirical backing
+- Logic (0-3): Is the reasoning sound? No fallacies? Does the conclusion follow from premises?
+  0 = deeply flawed, 1 = some logical problems, 2 = mostly sound, 3 = rigorous and valid
+- Relevance (0-2): Does it actually address and support the specific proposition?
+  0 = tangential, 1 = partially relevant, 2 = directly on-point
+- Originality (0-2): Is this a nuanced/specific point or a generic/obvious one?
+  0 = very common/generic, 1 = somewhat specific, 2 = genuinely nuanced insight
+
+Detect ALL logical fallacies present (from this list):
+${FALLACY_NAMES_FOR_PROMPT}
+
+Respond with a JSON object ONLY (no other text):
+{
+  "scores": {
+    "evidence": <0-3>,
+    "logic": <0-3>,
+    "relevance": <0-2>,
+    "originality": <0-2>
+  },
+  "fallacies": [
+    {
+      "type": "<fallacy_type_key>",
+      "name": "<Human readable name>",
+      "description": "<what this fallacy is>",
+      "explanation": "<exactly how it appears in this specific argument>",
+      "quote": "<the specific phrase in the argument that contains the fallacy>"
+    }
+  ],
+  "feedback": "<2-3 sentence evaluation: what's strong, what's weak, how it relates to the proposition>",
+  "strengtheningSuggestion": "<specific, actionable suggestion to make this argument stronger>"
+}`,
+            },
+        ],
+    });
+    const text = response.content.find(b => b.type === "text")?.text ?? "{}";
+    const jsonMatch = text.match(/\{[\s\S]*\}/);
+    if (!jsonMatch)
+        throw new Error("Failed to parse argument score from Claude");
+    const parsed = JSON.parse(jsonMatch[0]);
+    const score = {
+        evidence: Math.min(3, Math.max(0, parsed.scores.evidence)),
+        logic: Math.min(3, Math.max(0, parsed.scores.logic)),
+        relevance: Math.min(2, Math.max(0, parsed.scores.relevance)),
+        originality: Math.min(2, Math.max(0, parsed.scores.originality)),
+        total: Math.min(3, Math.max(0, parsed.scores.evidence)) +
+            Math.min(3, Math.max(0, parsed.scores.logic)) +
+            Math.min(2, Math.max(0, parsed.scores.relevance)) +
+            Math.min(2, Math.max(0, parsed.scores.originality)),
+    };
+    return {
+        text: params.argument,
+        score,
+        fallacies: parsed.fallacies || [],
+        feedback: parsed.feedback || "",
+        strengtheningSuggestion: parsed.strengtheningSuggestion || "",
+        timestamp: new Date().toISOString(),
+    };
+}
+// ─── Steel-Man Generation ──────────────────────────────────────────────────
+export async function generateSteelman(session) {
+    const proArgsSummary = session.proArguments
+        .map((a, i) => `${i + 1}. "${a.text}" (Score: ${a.score.total}/10)`)
+        .join("\n");
+    const response = await client.messages.create({
+        model: MODEL,
+        max_tokens: 3000,
+        messages: [
+            {
+                role: "user",
+                content: `You are a master debater and philosopher. A student has just argued FOR the following proposition.
+
+PROPOSITION: "${session.proposition}"
+
+THE STUDENT'S ARGUMENTS (arguing FOR):
+${proArgsSummary}
+
+Your task: Present the STRONGEST POSSIBLE CASE AGAINST this proposition.
+This is steel-manning — you must construct the best version of the opposing argument,
+not a straw man. Think like the best lawyer for the opposing side.
+
+Rules:
+- Engage with the actual strongest version of the opposing position
+- Use real evidence, studies, and expert perspectives where possible
+- Acknowledge any valid points in the student's arguments while showing their limits
+- Be intellectually honest — this should be a genuinely challenging counter-case
+- This will help the student understand what they're really up against
+
+Respond with a JSON object ONLY:
+{
+  "steelman": "<A compelling, well-reasoned paragraph (150-250 words) presenting the strongest case AGAINST the proposition. Write in first person as if you are arguing this side.>",
+  "keyCounterArguments": [
+    "<Counter-argument 1: specific, evidence-backed, most powerful>",
+    "<Counter-argument 2: addresses a weakness in the student's arguments>",
+    "<Counter-argument 3: presents a genuine trade-off or unintended consequence>",
+    "<Counter-argument 4: philosophical or values-based counter>",
+    "<Counter-argument 5: empirical/practical counter>"
+  ]
+}`,
+            },
+        ],
+    });
+    const text = response.content.find(b => b.type === "text")?.text ?? "{}";
+    const jsonMatch = text.match(/\{[\s\S]*\}/);
+    if (!jsonMatch)
+        throw new Error("Failed to parse steelman from Claude");
+    return JSON.parse(jsonMatch[0]);
+}
+// ─── Debate Synthesis ──────────────────────────────────────────────────────
+export async function generateSynthesis(session) {
+    const proArgsSummary = session.proArguments
+        .map((a, i) => `  ${i + 1}. "${a.text.substring(0, 100)}..." — Score: ${a.score.total}/10, Fallacies: ${a.fallacies.length}`)
+        .join("\n");
+    const conArgsSummary = session.conArguments
+        .map((a, i) => `  ${i + 1}. "${a.text.substring(0, 100)}..." — Score: ${a.score.total}/10, Fallacies: ${a.fallacies.length}`)
+        .join("\n");
+    const proAvg = session.proArguments.length > 0
+        ? (session.proArguments.reduce((s, a) => s + a.score.total, 0) /
+            session.proArguments.length).toFixed(1)
+        : "N/A";
+    const conAvg = session.conArguments.length > 0
+        ? (session.conArguments.reduce((s, a) => s + a.score.total, 0) /
+            session.conArguments.length).toFixed(1)
+        : "N/A";
+    const response = await client.messages.create({
+        model: MODEL,
+        max_tokens: 2000,
+        messages: [
+            {
+                role: "user",
+                content: `You are a master debate coach providing a final synthesis after a student has argued BOTH sides of a proposition.
+
+PROPOSITION: "${session.proposition}"
+
+ARGUMENTS FOR (avg score: ${proAvg}/10):
+${proArgsSummary}
+
+ARGUMENTS AGAINST (avg score: ${conAvg}/10):
+${conArgsSummary}
+
+Write a final synthesis (200-300 words) that:
+1. Acknowledges what the student did well on BOTH sides
+2. Identifies the strongest arguments that emerged from the full debate
+3. Explains what "the strongest version of this debate" looks like — what would a professional debater argue on each side?
+4. Names the key tension or core value clash at the heart of this debate
+5. Leaves the student with a philosophical insight about why these debates matter
+
+Be encouraging but honest. This synthesis should make the student feel they've grown intellectually.
+
+Write as flowing prose, no bullet points, no JSON — just a thoughtful paragraph.`,
+            },
+        ],
+    });
+    return response.content.find(b => b.type === "text")?.text ?? "Debate completed.";
+}
+// ─── Argument Builder Scaffold ─────────────────────────────────────────────
+export async function scaffoldArgument(params) {
+    const response = await client.messages.create({
+        model: MODEL,
+        max_tokens: 1024,
+        messages: [
+            {
+                role: "user",
+                content: `You are a Socratic debate coach. A student wants to argue ${params.position} on this proposition:
+
+"${params.proposition}"
+
+The student says: "${params.userThought}"
+
+Guide them to build a stronger argument using the Socratic method.
+
+Respond with JSON ONLY:
+{
+  "questions": [
+    "<Question 1: ask them to clarify or deepen their belief>",
+    "<Question 2: ask for evidence or examples>",
+    "<Question 3: ask how they'd respond to the strongest counter-argument>",
+    "<Question 4: ask about trade-offs or unintended consequences>"
+  ],
+  "hint": "<1-sentence suggestion for how to turn their thought into a strong argument>"
+}`,
+            },
+        ],
+    });
+    const text = response.content.find(b => b.type === "text")?.text ?? "{}";
+    const jsonMatch = text.match(/\{[\s\S]*\}/);
+    if (!jsonMatch)
+        throw new Error("Failed to parse scaffold from Claude");
+    return JSON.parse(jsonMatch[0]);
+}
+// ─── Format Scoring Output ─────────────────────────────────────────────────
+export function formatScoredArgument(arg) {
+    const scoreEmoji = (score, max) => {
+        const pct = score / max;
+        if (pct >= 0.8)
+            return "✅";
+        if (pct >= 0.5)
+            return "⚠️";
+        return "❌";
+    };
+    const lines = [
+        `**Score: ${arg.score.total}/10**`,
+        "",
+        `${scoreEmoji(arg.score.evidence, 3)} **Evidence (${arg.score.evidence}/3):** ${arg.score.evidence === 3 ? "Strong factual backing" : arg.score.evidence === 2 ? "Reasonable support" : arg.score.evidence === 1 ? "Vague, needs specifics" : "No evidence — pure opinion"}`,
+        `${scoreEmoji(arg.score.logic, 3)} **Logic (${arg.score.logic}/3):** ${arg.score.logic === 3 ? "Sound and valid reasoning" : arg.score.logic === 2 ? "Mostly sound reasoning" : arg.score.logic === 1 ? "Some logical problems" : "Flawed reasoning"}`,
+        `${scoreEmoji(arg.score.relevance, 2)} **Relevance (${arg.score.relevance}/2):** ${arg.score.relevance === 2 ? "Directly supports the proposition" : arg.score.relevance === 1 ? "Partially relevant" : "Off-topic"}`,
+        `${scoreEmoji(arg.score.originality, 2)} **Originality (${arg.score.originality}/2):** ${arg.score.originality === 2 ? "Nuanced insight" : arg.score.originality === 1 ? "Somewhat specific" : "Common/generic point"}`,
+        "",
+        `**Feedback:** ${arg.feedback}`,
+        "",
+        `💡 **Could strengthen:** ${arg.strengtheningSuggestion}`,
+    ];
+    if (arg.fallacies.length > 0) {
+        lines.push("");
+        lines.push(`**⚠️ Logical fallacies detected (${arg.fallacies.length}):**`);
+        for (const fallacy of arg.fallacies) {
+            lines.push(`- **${fallacy.name}**: ${fallacy.explanation}`);
+            if (fallacy.quote)
+                lines.push(`  *"${fallacy.quote}"*`);
+        }
+    }
+    else {
+        lines.push("");
+        lines.push("**✅ No logical fallacies detected**");
+    }
+    return lines.join("\n");
+}
+//# sourceMappingURL=claude.js.map