socratic-method 0.1.0__py3-none-any.whl

socratic_method/__init__.py

@@ -0,0 +1,11 @@
+"""socratic-method — a Socratic questioning skill for coding agents, with an installer.
+
+The skill (``assets/SKILL.md``) turns an agent into a disciplined Socratic questioner
+that interrogates an idea before real work starts and synthesizes an ``idea-brief-v1``
+artifact. This package ships the skill, a deterministic brief validator, and a ``setup``
+command that installs the skill for Claude Code, OpenAI Codex, and GitHub Copilot.
+"""
+
+__version__ = "0.1.0"
+
+SKILL_NAME = "socratic-method"

socratic_method/assets/SKILL.md

@@ -0,0 +1,240 @@
+---
+name: socratic-method
+description: "Interrogates the user's idea with disciplined Socratic questioning until hidden assumptions, contradictions, and gaps are surfaced, then synthesizes a refined idea brief (idea-brief-v1). Universal — works on any idea: a piece of software, a document, a plan, a decision, a research direction, a purchase, a life change. Use BEFORE real work or commitment starts. Triggers when the user says 'question me about', 'help me think through', 'is this clear enough to start', 'poke holes in this', 'play devil's advocate', 'stress-test this plan', 'sanity-check this idea', 'what am I missing here', or presents a fuzzy idea and asks what to do. Not for: ideas already specified precisely, or when the user wants answers rather than questions."
+allowed-tools: AskUserQuestion, Read, Write
+---
+
+## Purpose
+
+The Socratic method (elenchus) tests a belief by questioning it until its hidden assumptions
+and contradictions are exposed. Its modern form — Socratic questioning — is a cooperative
+dialogue: the questioner does not lecture or propose; they draw the idea out of the person who
+holds it (maieutics, "midwifery"), and treat reaching honest puzzlement (aporia) as progress,
+not failure.
+
+This skill turns Claude into that questioner. The user brings an idea — *any* idea: a thing to
+build, a document to write, a decision to make, a plan to commit to, a direction to research —
+and Claude questions it until it is either sharpened into something actionable or honestly
+shown to be unresolved. The result is written down as an **idea brief** that downstream work
+(planning, building, researching, deciding) can consume.
+
+**You are the questioner, not the answerer.** Until the synthesis phase you contribute no
+solutions, no designs, no recommendations, no "have you considered X". Your only tools are
+questions, restatements, and counterexamples. The method is domain-neutral: never let the
+subject matter pull you into acting as a domain expert instead of an examiner.
+
+## Invocation
+
+```
+/socratic-method <idea> [--mode stress|develop] [--depth quick|standard|deep]
+```
+
+- **mode** — the questioning stance:
+  - `stress` (classic elenchus): hunt for contradictions and counterexamples; refuting the
+    idea counts as success. For ideas the user is about to invest heavily in.
+  - `develop` (guided discovery): supportive questioning that helps articulate and grow a
+    fragile early idea rather than attack it.
+- **depth** — the cadence budget:
+  - `quick`: two rounds of 2–3 grouped questions, then synthesis. A sanity pass.
+  - `standard` (default): one question per turn, ~8–12 questions.
+  - `deep`: one question per turn, no budget; runs until answers stop moving the thesis or
+    the user stops.
+
+**Setup turn:** if mode or depth is missing, ask for both in one exchange at the start —
+a structured multiple-choice prompt where the tool supports it (`AskUserQuestion` on Claude
+Code), plain text otherwise. Propose a default and let the user override it. Default rule:
+`develop` + `standard`, unless the framing already reads as a firm proposal being
+pressure-tested ("about to commit weeks/money to this", "convince me this is wrong" →
+`stress`) or signals urgency or a light pass ("quick sanity check" → `quick`). If no idea was
+given at all, the opening move is to ask for it.
+
+## Procedure
+
+### Phase 1 — Thesis
+
+Get the idea stated in the user's own words, compressed:
+
+> "State the idea in one or two sentences, as if convincing a skeptical friend."
+
+Restate it back neutrally (steelman it — the strongest honest version, never a strawman) and
+ask if the restatement is right. If the user corrects or rejects it, restate the **corrected**
+thesis and get an explicit confirmation before asking any Phase 2 question — never begin
+probing on an unconfirmed thesis, however clear the correction seemed. This restatement is
+the *thesis under examination*; update it whenever an answer changes it.
+
+**Scope check (before any Phase 2 question):** if the idea is already precisely specified —
+clear scope, an owner, measurable success criteria, no open questions — or the user signals
+they don't want questioning, this is the "Not for" case: say so and stop rather than
+manufacture doubts. Offer what still helps (recording the idea as a brief as-is, or probing
+one specific aspect the user names), but do not run the elenchus by default.
+
+### Phase 2 — Elenchus (the questioning rounds)
+
+At `standard`/`deep`, ask **exactly one question per turn** — never bundling — and wait for
+the answer: the adaptivity (each question chosen from the last answer) is where the value
+comes from. At `quick`, group 2–3 related questions per turn as plain prose — never as
+multiple-choice chips, which would collapse the very ambiguity being examined. At any depth,
+never ask a checklist (a bulleted or numbered list of questions — a quick-mode group must
+read as one connected paragraph) and never answer your own question.
+
+Choose each question for maximum information gain against the *current* thesis, drawing from
+the six classic Socratic question types:
+
+| Type | Probes | Example shape |
+|------|--------|---------------|
+| Clarification | vague terms, scope | "When you say 'better', better for whom, measured how?" |
+| Assumptions | what's taken for granted | "This assumes you'll still want this in a year. What tells you that?" |
+| Evidence & reasons | why the user believes it | "What have you actually seen or tried that supports this?" |
+| Viewpoints & alternatives | competing framings | "How would someone happy with the status quo describe your idea?" |
+| Implications & consequences | where it leads | "If this works exactly as hoped, what does it displace or break?" |
+| Questioning the question | the framing itself | "Is 'which option' the real question, or is it 'whether at all'?" |
+
+Tactics that do the heavy lifting:
+
+- **Counterexample:** when the user states a general rule ("everyone needs X"), offer one
+  concrete case that strains it and ask how the idea handles it.
+- **Contradiction surfacing:** when two answers conflict, quote both back verbatim and ask
+  which one yields. Do not smooth the conflict over yourself.
+- **Definition pressure:** any load-bearing word used twice with two meanings gets a
+  "define it once" question.
+- **Concreteness pull:** abstract answer → ask for one specific instance ("walk me through
+  the very first time this gets used, step by step").
+
+Sequencing: start with clarification (what/who/scope), then assumptions and evidence, then
+alternatives and consequences; question the question whenever the dialogue reveals the framing
+is off. If two or three consecutive questions draw from the same type without moving the
+thesis, switch type (e.g. consequences → questioning-the-question) or go to the Phase 3
+checkpoint. In `stress` mode, weight toward counterexamples and contradiction surfacing; in
+`develop` mode, weight toward clarification and concreteness pulls, and probe gently.
+
+**Incremental capture:** whenever an answer changes the thesis or surfaces a new assumption,
+contradiction, or open question, silently update the draft brief at the output path (Phase 4
+format, `verdict: aporia` while in progress). An interrupted or abandoned session must still
+leave a usable partial brief.
+
+### Phase 3 — Verdict checkpoint
+
+Stop questioning when (whichever comes first): the depth budget is spent; answers stop
+changing the thesis; or the user says stop. Then state honestly which state was reached:
+
+- **Sharpened:** the thesis survived, now with explicit scope, assumptions, and constraints.
+- **Aporia:** a genuine unresolved hole remains. Name it plainly. Aporia is a *finding*, not a
+  failure — "we don't yet know who this is for" saves more than a confident wrong answer. Do
+  not paper over it with a proposed solution. Aporia also hides behind a "sharpened" label:
+  if the final thesis is mainly a plan to answer the open questions ("first find out X /
+  go ask / define the metric"), the verdict is aporia — the gathering plan belongs in
+  `next_step`, not the thesis. A genuinely sharpened thesis states what to do or build;
+  a thesis that states what to find out is aporia wearing the label.
+- **Refuted:** two of the user's own answers collided and could not be reconciled. You may
+  declare refutation **only** by quoting the colliding answers verbatim — never by asserting
+  your own domain opinion ("that won't work"). The method refutes people out of their own
+  mouth, or not at all. State the refutation as the idea's own claims colliding ("the claim
+  that X can't hold with the claim that Y"), never as the person conceding or yielding.
+
+### Phase 4 — Maieutic synthesis (the deliverable)
+
+Only now may you contribute content. Produce the **idea brief**, built strictly from the
+user's own answers (cite their words; invent nothing they didn't say).
+
+Format — `idea-brief-v1`, a markdown file with YAML frontmatter. The format is formal:
+the packaged schema (`idea-brief-v1.schema.json`, installed alongside this skill's source)
+defines the frontmatter, and the harness validates briefs with `socratic-method validate
+<path>` (the eval matrix in the package repository's `evals/` runs it on every brief):
+
+```markdown
+---
+schema: idea-brief-v1
+idea: <slug>            # slug only, no date — the filename adds -YYYYMMDD
+date: <YYYY-MM-DD>
+mode: stress            # stress | develop
+depth: standard         # quick | standard | deep
+verdict: sharpened      # sharpened | aporia | refuted
+thesis_final: "One- or two-sentence refined statement"
+questions_asked: 9      # Phase 2 probing questions only (not the thesis ask, steelman
+#                       # confirmations, or clarifying sub-questions of the same probe);
+#                       # recount from the conversation when writing — never estimate
+types_used: [clarification, assumptions, evidence]   # exact tokens: clarification |
+#   assumptions | evidence | viewpoints | implications | questioning-the-question
+# colliding_claims: ["quote 1", "quote 2"]   # REQUIRED when verdict: refuted — the two
+#                                            # colliding answers, verbatim as the user said them
+assumptions:
+  - text: "..."
+    status: unvalidated # validated | unvalidated | risky
+open_questions:
+  - "..."
+constraints:
+  - "..."
+next_step: "One concrete action"
+---
+
+# Idea brief: <short name>
+## What changed under questioning   — initial vs final thesis, a line or two each
+## Scope                            — who/what it's for, and what is explicitly out
+## Assumptions surfaced             — narrative behind the frontmatter list
+## Contradictions & how resolved    — or "unresolved", carried to open questions
+## Open questions (aporia)          — what must be answered before/while proceeding
+## Suggested next step
+```
+
+Write it to `notes/idea-briefs/<slug>.md` (create the directory if needed; honor a
+user-supplied path instead). Derive the slug from the idea plus the date
+(`<idea-slug>-YYYYMMDD`, lowercase letters/digits/hyphens only — never path characters from
+free-text input); if the file already exists, read it first and overwrite only if it
+is an earlier draft of this same dialogue — otherwise pick a suffixed name. Never write into
+areas owned by generators or other tooling (for example generated-artifact directories such
+as `.claude/agents/generated/`). Print the brief in chat as well.
+
+**Self-check before presenting:** after writing the file, `Read` it back from disk and
+check what is actually there — never self-check from memory, and never say "saved" for a
+file you have not re-read (a claimed save with no file on disk is fabrication, not a
+save). Verify: every required frontmatter key present and enum-valid — including keys
+with nothing gathered, which still appear with an empty list (`[]`); every assumption
+carries a status; `questions_asked` recounted from the conversation, not estimated;
+`verdict: aporia` ⇒ `open_questions` non-empty; `verdict: refuted` ⇒ `colliding_claims`
+holds the two colliding answers exactly as the user said them, and both appear in the
+body. Fix mismatches before printing. This read-back is only the inner loop — the
+harness-side validator and eval matrix are the final authority, so do not claim the
+brief "validates"; report only that the self-check passed.
+
+A complete worked example — a sample exchange showing the steelman restatement,
+contradiction-surfacing, and a verbatim-quote refutation, plus a full `idea-brief-v1` file —
+is in [references/example-session.md](references/example-session.md). Consult it before
+writing your first brief of a session.
+
+## Combining with other skills
+
+This skill is a *front-end*: the brief is the input that makes downstream work better. The
+frontmatter is designed for mechanical hand-off — `open_questions` is a ready-made research
+agenda, `assumptions[status=unvalidated]` is a validation worklist.
+
+- **Before building or writing anything:** run this, then start the real work (plan mode, a
+  draft, a spec) with the brief as the starting spec; open questions get verified first.
+- **Before research** (e.g. `deep-research`): pass `open_questions` and unvalidated
+  assumptions as the research questions.
+- **Before authoring an agent, skill, or subagent:** question the idea — domain, sources,
+  who consults it, what "good advice" means — before building anything; the brief informs
+  scope and source selection.
+- **Chained by another skill:** any skill may invoke this one first when its own input is
+  fuzzy; it returns control once the brief exists.
+
+## Guardrails
+
+- One question per turn at `standard`/`deep`; small prose groups only at `quick`. No
+  checklists, no "also, ...".
+- No solutions, designs, or recommendations before Phase 4 — even if asked "what would you
+  do?", answer once with a question that helps the *user* decide, and offer to move to
+  synthesis if they'd rather stop.
+- Stay the examiner: do not drift into domain-expert mode, whatever the subject.
+- Non-adversarial tone even in `stress` mode: you are examining the idea, not the person.
+  Steelman before you probe.
+- Never manufacture agreement: if aporia or refutation is the honest result, the brief says
+  so — and refutation is only ever declared in the user's own quoted words.
+- Respect the stop signal instantly, including soft forms: "stop", "that's enough", "I'm
+  done", "let's not re-walk this" → go straight to Phase 4 with whatever was gathered. Never
+  politely push past a stop signal with more questions.
+
+## Source
+
+Distilled from the standard account of the Socratic method
+(https://en.wikipedia.org/wiki/Socratic_method): classic elenchus and aporia, maieutics, and
+the modern Socratic-questioning taxonomy used in education and cognitive-behavioural therapy.

socratic_method/assets/idea-brief-v1.schema.json

@@ -0,0 +1,97 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "idea-brief-v1.schema.json",
+  "title": "idea-brief-v1 frontmatter",
+  "description": "YAML frontmatter of an idea brief produced by the socratic-method skill (.claude/skills/socratic-method). The markdown body is checked separately by tools/subagent_factory/validate_idea_brief.py (required headers, verbatim colliding claims).",
+  "type": "object",
+  "required": [
+    "schema",
+    "idea",
+    "date",
+    "mode",
+    "depth",
+    "verdict",
+    "thesis_final",
+    "assumptions",
+    "open_questions",
+    "constraints",
+    "next_step"
+  ],
+  "properties": {
+    "schema": { "const": "idea-brief-v1" },
+    "idea": {
+      "type": "string",
+      "pattern": "^[a-z0-9][a-z0-9-]*$",
+      "description": "Slug: lowercase letters, digits, hyphens only."
+    },
+    "date": {
+      "type": "string",
+      "pattern": "^\\d{4}-\\d{2}-\\d{2}$"
+    },
+    "mode": { "enum": ["stress", "develop"] },
+    "depth": { "enum": ["quick", "standard", "deep"] },
+    "verdict": { "enum": ["sharpened", "aporia", "refuted"] },
+    "thesis_final": { "type": "string", "minLength": 1 },
+    "assumptions": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["text", "status"],
+        "properties": {
+          "text": { "type": "string", "minLength": 1 },
+          "status": { "enum": ["validated", "unvalidated", "risky"] }
+        },
+        "additionalProperties": false
+      }
+    },
+    "open_questions": {
+      "type": "array",
+      "items": { "type": "string", "minLength": 1 }
+    },
+    "constraints": {
+      "type": "array",
+      "items": { "type": "string", "minLength": 1 }
+    },
+    "next_step": { "type": "string", "minLength": 1 },
+    "questions_asked": {
+      "type": "integer",
+      "minimum": 0,
+      "description": "Total elenchus questions the examiner asked (auditable session claim)."
+    },
+    "types_used": {
+      "type": "array",
+      "uniqueItems": true,
+      "items": {
+        "enum": [
+          "clarification",
+          "assumptions",
+          "evidence",
+          "viewpoints",
+          "implications",
+          "questioning-the-question"
+        ]
+      },
+      "description": "Which of the six Socratic question types were used."
+    },
+    "colliding_claims": {
+      "type": "array",
+      "minItems": 2,
+      "maxItems": 2,
+      "items": { "type": "string", "minLength": 1 },
+      "description": "verdict=refuted only: the two user answers that collided, quoted verbatim."
+    }
+  },
+  "additionalProperties": false,
+  "allOf": [
+    {
+      "if": { "properties": { "verdict": { "const": "refuted" } } },
+      "then": { "required": ["colliding_claims"] }
+    },
+    {
+      "if": { "properties": { "verdict": { "const": "aporia" } } },
+      "then": {
+        "properties": { "open_questions": { "minItems": 1 } }
+      }
+    }
+  ]
+}

socratic_method/assets/references/example-session.md

@@ -0,0 +1,155 @@
+# Worked example — socratic-method session
+
+A condensed but realistic session, chosen deliberately from a **non-software** domain to
+anchor the skill's universality. It demonstrates the style-sensitive moves: the steelman
+restatement, one question per turn, contradiction surfacing by verbatim quotation, the
+difference between a refutation declaration and aporia, and the exact `idea-brief-v1` shape.
+
+Invocation: `/socratic-method I want to start a weekly tech-talk series at work --mode stress --depth standard`
+
+## The exchange (abridged)
+
+**Agent (Phase 1 — thesis):**
+> State the idea in one or two sentences, as if convincing a skeptical friend.
+
+**User:** We should run a weekly 30-minute tech talk every Friday. People barely know what
+other teams are doing, and it'd help juniors learn faster.
+
+**Agent (steelman restatement — strongest honest version, then confirm):**
+> So the thesis is: *a recurring weekly 30-minute internal talk will fix cross-team
+> visibility and accelerate junior growth, and weekly cadence is essential to that.* Is that
+> the claim — including the "weekly is essential" part?
+
+**User:** Yes, weekly, otherwise it loses momentum.
+
+**Agent (Phase 2 — clarification, one question only):**
+> When you say "people barely know what other teams are doing" — who specifically has told
+> you that, and what did it cost them?
+
+**User:** Mostly me, honestly. I was blindsided by the platform team's migration last month.
+
+**Agent (assumptions):**
+> The plan assumes a steady supply of speakers — roughly 50 talks a year. Who, concretely,
+> gives talks 3 through 10?
+
+**User:** That's the weak spot. Realistically I'd be begging people. Most engineers here hate
+presenting.
+
+**Agent (contradiction surfacing — both answers quoted verbatim, user chooses which yields):**
+> Two of your answers are now in tension. You said **"weekly, otherwise it loses momentum"**,
+> and you said **"realistically I'd be begging people. Most engineers here hate presenting."**
+> A cadence that outruns your speaker supply doesn't build momentum — it builds visible
+> no-shows. Which one yields: the weekly cadence, or the assumption that momentum requires it?
+
+**User:** …the cadence, I guess. Monthly with strong talks beats weekly with filler.
+
+*(The thesis is updated; questioning continues through evidence, alternatives, and
+consequences until answers stop moving it.)*
+
+**Agent (Phase 3 — verdict checkpoint):**
+> Verdict: **sharpened, with one open hole.** The idea survived, but transformed: monthly, not
+> weekly; and the evidence for the visibility problem is currently a sample of one (your
+> migration surprise). That's an unvalidated assumption, not a refuted idea — so this is
+> carried as an open question, not declared refuted.
+
+### How a refutation would have read instead
+
+Refutation is declared **only** out of the user's own mouth. If the user had insisted the
+cadence must stay weekly, it would read:
+
+> Verdict: **refuted as stated.** You said **"weekly, otherwise it loses momentum"** and you
+> said **"realistically I'd be begging people. Most engineers here hate presenting"** — and
+> when asked which claim yields, neither did. The claim that momentum requires weekly cadence
+> can't hold with the claim that speakers must be begged: the idea as stated contradicts
+> itself, and here is what would need to change for it to survive.
+
+Never: "weekly won't work at your company" — that is the agent's domain opinion, which is not
+grounds for refutation.
+
+### How a pure aporia verdict would have read instead
+
+Aporia is the honest terminus when questioning exhausts the budget and a load-bearing hole
+remains that no amount of further dialogue can fill *right now* — the thesis is neither
+sharpened into something actionable nor self-contradictory. If the user had answered "I
+genuinely don't know" to both the speaker-supply and the who-feels-this-problem questions, it
+would read:
+
+> Verdict: **aporia.** The idea didn't collapse — but its two load-bearing inputs are
+> unknowns you can't answer from where you sit: whether anyone besides you feels the
+> visibility gap, and whether anyone at all will volunteer to speak. Until those are known,
+> any cadence decision is guesswork. That's the finding: this isn't ready to decide, and the
+> brief records exactly what would make it ready.
+
+The brief then carries `verdict: aporia`, the unknowns as `open_questions`, and a `next_step`
+that gathers the missing answers — never a proposed solution that papers over them. Aporia is
+delivered as a *result*, not an apology.
+
+## The deliverable — `notes/idea-briefs/tech-talk-series-20260704.md`
+
+```markdown
+---
+schema: idea-brief-v1
+idea: tech-talk-series
+date: 2026-07-04
+mode: stress
+depth: standard
+verdict: sharpened
+thesis_final: "A monthly 30-minute internal tech talk, seeded with 3 pre-committed speakers,
+  to improve cross-team visibility — piloted for a quarter before any cadence increase."
+questions_asked: 9
+types_used: [clarification, assumptions, evidence, implications]
+assumptions:
+  - text: "Cross-team visibility is a widely felt problem, not just the proposer's"
+    status: unvalidated
+  - text: "Enough engineers will volunteer to speak at monthly cadence"
+    status: risky
+  - text: "30 minutes is short enough that attendance survives busy weeks"
+    status: unvalidated
+open_questions:
+  - "Do at least 5 other people report being surprised by another team's work in the last quarter?"
+  - "Who are speakers 1-3, by name, before anything is announced?"
+constraints:
+  - "No budget; must run on existing meeting infrastructure"
+  - "Cannot be mandatory (user: 'the moment it's mandatory it's dead')"
+next_step: "Ask the last 5 people who joined what they wish they'd known — validates the
+  visibility assumption before committing anyone's Friday."
+---
+
+# Idea brief: internal tech-talk series
+
+## What changed under questioning
+Initial: weekly talks to fix visibility and grow juniors, weekly cadence essential.
+Final: monthly pilot with pre-committed speakers; the junior-growth goal was dropped as a
+separate untested claim riding along with the visibility one.
+
+## Scope
+For: engineers across teams at the user's company. Out of scope: external audience,
+recorded-content library, mandatory attendance.
+
+## Assumptions surfaced
+The visibility problem rests on a sample of one (the user's own migration surprise). Speaker
+supply was the load-bearing weakness: the user's own words — "I'd be begging people" —
+forced the cadence change.
+
+## Contradictions & how resolved
+"Weekly, otherwise it loses momentum" vs "most engineers here hate presenting" — resolved by
+the user: cadence yielded ("monthly with strong talks beats weekly with filler").
+
+## Open questions (aporia)
+Whether the visibility problem is real beyond the user, and who the first three named
+speakers are. Both must be answered before announcing anything.
+
+## Suggested next step
+Interview the last 5 joiners about what they wish they'd known. Cheap, fast, and directly
+tests the founding assumption.
+```
+
+## What to imitate
+
+- The restatement adds the hidden rider ("weekly is essential") *and asks for confirmation* —
+  that rider is what later collides.
+- Exactly one question per message; each names why it matters only when that isn't obvious.
+- The contradiction move quotes **both answers verbatim in bold** and hands the choice to the
+  user — the agent never resolves it.
+- Frontmatter values come from the user's answers; the `constraints` entry even cites their
+  wording. Nothing in the brief was invented by the agent.

socratic_method/cli.py

@@ -0,0 +1,151 @@
+"""socratic-method command-line interface.
+
+Subcommands:
+    setup      install/refresh the skill for Claude Code, Codex, and/or Copilot
+    status     show what is installed where, and whether it matches this package
+    uninstall  remove managed skill files
+    validate   check an idea brief against the idea-brief-v1 format
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from . import __version__
+from .installer import PLATFORMS, detect_platforms, install, status, uninstall
+from .validator import validate_idea_brief
+
+_TARGET_CHOICES = [*PLATFORMS.keys(), "all"]
+
+
+def _targets(raw: list[str]) -> list[str]:
+    bad = [t for t in raw if t not in _TARGET_CHOICES]
+    if bad:
+        raise SystemExit(
+            f"unknown target(s): {', '.join(bad)} (choose from {', '.join(_TARGET_CHOICES)})"
+        )
+    return list(PLATFORMS) if (not raw or "all" in raw) else list(dict.fromkeys(raw))
+
+
+def _print_action(a) -> None:
+    mark = {
+        "installed": "+",
+        "up-to-date": "=",
+        "skipped": "~",
+        "would-install": ">",
+        "blocked": "!",
+        "removed": "-",
+        "not-installed": " ",
+        "partial-or-modified": "!",
+    }.get(a.outcome, "?")
+    line = f" [{mark}] {a.platform:8s} {a.scope:8s} {a.outcome:20s} {a.target}"
+    print(line)
+    if a.detail:
+        print(f"      {a.detail}")
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="socratic-method",
+        description="Socratic questioning skill for coding agents — installer and brief validator.",
+    )
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    p_setup = sub.add_parser("setup", help="install/refresh the skill for one or more platforms")
+    p_setup.add_argument(
+        "targets",
+        nargs="*",
+        metavar="TARGET",
+        help=f"platforms to set up: {', '.join(_TARGET_CHOICES)} "
+        "(default: auto-detect installed agents)",
+    )
+    p_setup.add_argument(
+        "--scope",
+        choices=["project", "user"],
+        default="project",
+        help="install into the current project (default) or the user home",
+    )
+    p_setup.add_argument(
+        "--root",
+        type=Path,
+        default=Path.cwd(),
+        help="project root for --scope project (default: cwd)",
+    )
+    p_setup.add_argument(
+        "--force",
+        action="store_true",
+        help="overwrite an existing install that differs from this package",
+    )
+    p_setup.add_argument("--dry-run", action="store_true", help="print the plan, write nothing")
+
+    p_status = sub.add_parser("status", help="show install state for every platform and scope")
+    p_status.add_argument("--root", type=Path, default=Path.cwd())
+
+    p_un = sub.add_parser("uninstall", help="remove managed skill files")
+    p_un.add_argument("targets", nargs="*", metavar="TARGET")
+    p_un.add_argument("--scope", choices=["project", "user"], default="project")
+    p_un.add_argument("--root", type=Path, default=Path.cwd())
+    p_un.add_argument("--dry-run", action="store_true")
+
+    p_val = sub.add_parser("validate", help="validate an idea-brief-v1 file")
+    p_val.add_argument("brief", type=Path, help="path to the brief markdown file")
+
+    args = parser.parse_args(argv)
+    home = Path.home()
+
+    if args.command == "validate":
+        errors = validate_idea_brief(args.brief)
+        for e in errors:
+            print(f"ERROR: {e}")
+        if not errors:
+            print(f"OK: {args.brief} is a valid idea-brief-v1")
+        return 0 if not errors else 1
+
+    if args.command == "status":
+        print(f"socratic-method {__version__} — install status (project root: {args.root})")
+        detected = detect_platforms(home)
+        for key, ev in detected.items():
+            print(f"  agent {key:8s} {'detected: ' + ev if ev else 'not detected'}")
+        for a in status(args.root, home):
+            _print_action(a)
+        return 0
+
+    if args.command == "setup" and not args.targets:
+        # Auto-detect which agents are installed; configure only those.
+        detected = detect_platforms(home)
+        for key, ev in detected.items():
+            print(f"  agent {key:8s} {'detected: ' + ev if ev else 'not detected'}")
+        keys = [k for k, ev in detected.items() if ev]
+        if not keys:
+            print(
+                "No supported agent detected on this machine. Name targets explicitly, "
+                "e.g. `socratic-method setup claude` or `socratic-method setup all`."
+            )
+            return 1
+    else:
+        keys = _targets(args.targets)
+
+    rc = 0
+    for key in keys:
+        try:
+            if args.command == "setup":
+                a = install(
+                    key, args.scope, args.root, home, force=args.force, dry_run=args.dry_run
+                )
+            else:
+                a = uninstall(key, args.scope, args.root, home, dry_run=args.dry_run)
+        except ValueError as e:
+            print(f" [!] {key:8s} {args.scope:8s} error: {e}")
+            rc = 1
+            continue
+        _print_action(a)
+        if a.outcome == "blocked":
+            rc = 1
+    return rc
+
+
+if __name__ == "__main__":
+    sys.exit(main())

socratic_method/installer.py

@@ -0,0 +1,263 @@
+"""Install/inspect/remove the socratic-method skill for coding-agent platforms.
+
+Design rules (inherited from the skill's own eval-hardened history):
+
+- **Idempotent.** Every managed file is compared by content before writing;
+  an identical install is reported "up to date", never rewritten.
+- **Never clobber local edits silently.** A file that differs from the packaged
+  version requires ``force=True`` to overwrite.
+- **Verify before claiming.** After writing, every file is read back from disk and
+  compared to the packaged content; "installed" is only reported when the read-back
+  matches. A claimed install with no verified file is the failure mode this skill
+  exists to prevent.
+
+Platform skill directories (data-driven so corrections are one-line; grounded in the
+platform research of the agent-skills-advisor corpus — see README for caveats):
+
+- Claude Code: ``.claude/skills/`` (project) and ``~/.claude/skills/`` (user).
+- OpenAI Codex: ``.agents/skills/`` (project) and ``~/.agents/skills/`` (user) —
+  Codex scans the open Agent Skills directory, not ``.claude/skills``.
+- GitHub Copilot: ``.github/skills/`` (project). Copilot also reads a repo's
+  ``.claude/skills/``, so a project-scope Claude install already covers Copilot;
+  the installer detects that and skips to avoid a double-triggering duplicate.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import hashlib
+import shutil
+from dataclasses import dataclass
+from importlib.resources import files
+from pathlib import Path
+
+from . import SKILL_NAME
+
+# Relative paths (within the skill directory) of every file this installer manages.
+MANAGED_FILES = (
+    "SKILL.md",
+    "references/example-session.md",
+    "idea-brief-v1.schema.json",
+)
+
+
+@dataclass(frozen=True)
+class Platform:
+    key: str
+    label: str
+    project_dir: str  # relative to --root
+    user_dir: str | None  # relative to ~; None = no user scope documented
+    note: str = ""
+
+
+PLATFORMS: dict[str, Platform] = {
+    "claude": Platform(
+        key="claude",
+        label="Claude Code",
+        project_dir=".claude/skills",
+        user_dir=".claude/skills",
+    ),
+    "codex": Platform(
+        key="codex",
+        label="OpenAI Codex",
+        project_dir=".agents/skills",
+        user_dir=".agents/skills",
+    ),
+    "copilot": Platform(
+        key="copilot",
+        label="GitHub Copilot",
+        project_dir=".github/skills",
+        user_dir=None,
+        note="reads a repo's .claude/skills too — a project Claude install covers it",
+    ),
+}
+
+
+def detect_platforms(home: Path, path_env: str | None = None) -> dict[str, str | None]:
+    """Detect which agents are installed on this machine.
+
+    Returns ``{platform_key: evidence_or_None}`` — evidence is the concrete signal
+    found (a CLI on PATH, a config directory, an editor extension), so every claimed
+    detection is verifiable. ``path_env`` overrides the PATH searched (for tests).
+    """
+
+    def which(cmd: str) -> str | None:
+        return shutil.which(cmd, path=path_env)
+
+    evidence: dict[str, str | None] = {}
+
+    if exe := which("claude"):
+        evidence["claude"] = f"claude CLI on PATH ({exe})"
+    elif (home / ".claude").is_dir():
+        evidence["claude"] = f"config directory {home / '.claude'}"
+    else:
+        evidence["claude"] = None
+
+    if exe := which("codex"):
+        evidence["codex"] = f"codex CLI on PATH ({exe})"
+    elif (home / ".codex").is_dir():
+        evidence["codex"] = f"config directory {home / '.codex'}"
+    else:
+        evidence["codex"] = None
+
+    if exe := which("copilot"):
+        evidence["copilot"] = f"copilot CLI on PATH ({exe})"
+    elif (home / ".local/share/gh/extensions/gh-copilot").is_dir():
+        evidence["copilot"] = "gh-copilot extension installed"
+    elif vsix := sorted((home / ".vscode" / "extensions").glob("github.copilot*")):
+        evidence["copilot"] = f"VS Code extension {vsix[-1].name}"
+    else:
+        evidence["copilot"] = None
+
+    return evidence
+
+
+def packaged_content(rel: str) -> bytes:
+    return files("socratic_method").joinpath(f"assets/{rel}").read_bytes()
+
+
+def _digest(data: bytes) -> str:
+    return hashlib.sha256(data).hexdigest()
+
+
+def skill_dir(platform: Platform, scope: str, root: Path, home: Path) -> Path:
+    """Resolve the target skill directory for a platform+scope."""
+    if scope == "project":
+        base = root / platform.project_dir
+    elif scope == "user":
+        if platform.user_dir is None:
+            raise ValueError(
+                f"{platform.label} has no documented user-scope skills directory; "
+                "use --scope project"
+            )
+        base = home / platform.user_dir
+    else:
+        raise ValueError(f"unknown scope '{scope}'")
+    return base / SKILL_NAME
+
+
+def file_state(target: Path, rel: str) -> str:
+    """One managed file's state: 'missing' | 'up-to-date' | 'differs'."""
+    dst = target / rel
+    if not dst.is_file():
+        return "missing"
+    return (
+        "up-to-date" if _digest(dst.read_bytes()) == _digest(packaged_content(rel)) else "differs"
+    )
+
+
+def install_state(target: Path) -> str:
+    """Whole-install state: 'not-installed' | 'up-to-date' | 'partial-or-modified'."""
+    states = {rel: file_state(target, rel) for rel in MANAGED_FILES}
+    if all(s == "missing" for s in states.values()):
+        return "not-installed"
+    if all(s == "up-to-date" for s in states.values()):
+        return "up-to-date"
+    return "partial-or-modified"
+
+
+@dataclass
+class Action:
+    platform: str
+    scope: str
+    target: Path
+    # 'installed' | 'up-to-date' | 'skipped' | 'would-install' | 'blocked' |
+    # 'removed' | 'not-installed'
+    outcome: str
+    detail: str = ""
+
+
+def install(
+    platform_key: str,
+    scope: str,
+    root: Path,
+    home: Path,
+    *,
+    force: bool = False,
+    dry_run: bool = False,
+) -> Action:
+    platform = PLATFORMS[platform_key]
+    target = skill_dir(platform, scope, root, home)
+
+    # Copilot dedupe: a project-scope Claude install in the same root already covers it.
+    if platform_key == "copilot" and scope == "project" and not force:
+        claude_target = skill_dir(PLATFORMS["claude"], "project", root, home)
+        if install_state(claude_target) == "up-to-date":
+            return Action(
+                platform_key,
+                scope,
+                target,
+                "skipped",
+                f"Copilot reads .claude/skills — already covered by {claude_target} "
+                "(use --force to install to .github/skills anyway)",
+            )
+
+    state = install_state(target)
+    if state == "up-to-date":
+        return Action(
+            platform_key, scope, target, "up-to-date", "all files match the packaged version"
+        )
+    if state == "partial-or-modified" and not force:
+        differing = [rel for rel in MANAGED_FILES if file_state(target, rel) == "differs"]
+        return Action(
+            platform_key,
+            scope,
+            target,
+            "blocked",
+            f"existing install differs from packaged version "
+            f"({', '.join(differing) or 'partial'}); re-run with --force to overwrite",
+        )
+    if dry_run:
+        return Action(platform_key, scope, target, "would-install", f"{len(MANAGED_FILES)} files")
+
+    for rel in MANAGED_FILES:
+        dst = target / rel
+        dst.parent.mkdir(parents=True, exist_ok=True)
+        dst.write_bytes(packaged_content(rel))
+
+    # Verify before claiming: read back every file from disk.
+    unverified = [rel for rel in MANAGED_FILES if file_state(target, rel) != "up-to-date"]
+    if unverified:
+        return Action(
+            platform_key,
+            scope,
+            target,
+            "blocked",
+            f"post-write verification FAILED for: {', '.join(unverified)}",
+        )
+    return Action(
+        platform_key,
+        scope,
+        target,
+        "installed",
+        f"{len(MANAGED_FILES)} files written and read back",
+    )
+
+
+def uninstall(
+    platform_key: str, scope: str, root: Path, home: Path, *, dry_run: bool = False
+) -> Action:
+    platform = PLATFORMS[platform_key]
+    target = skill_dir(platform, scope, root, home)
+    if install_state(target) == "not-installed":
+        return Action(platform_key, scope, target, "not-installed")
+    if dry_run:
+        return Action(platform_key, scope, target, "would-install", "would remove managed files")
+    for rel in MANAGED_FILES:
+        (target / rel).unlink(missing_ok=True)
+    # Remove now-empty directories we own, innermost first.
+    for d in sorted({(target / rel).parent for rel in MANAGED_FILES} | {target}, reverse=True):
+        with contextlib.suppress(OSError):  # not empty — user files present; leave them
+            d.rmdir()
+    return Action(platform_key, scope, target, "removed")
+
+
+def status(root: Path, home: Path) -> list[Action]:
+    out = []
+    for key, platform in PLATFORMS.items():
+        for scope in ("project", "user"):
+            if scope == "user" and platform.user_dir is None:
+                continue
+            target = skill_dir(platform, scope, root, home)
+            out.append(Action(key, scope, target, install_state(target)))
+    return out

socratic_method/validator.py

@@ -0,0 +1,113 @@
+"""Validate an idea brief produced by the socratic-method skill.
+
+Structural: YAML frontmatter validated against the packaged
+``idea-brief-v1.schema.json``. Cross-field rules the schema cannot express:
+
+- ``verdict: refuted`` — each ``colliding_claims`` entry must appear verbatim in the
+  markdown body (the skill may only refute out of the user's own quoted mouth);
+- required body headers from the skill's Phase 4 template must all be present;
+- the filename slug (when the file follows ``<idea-slug>-YYYYMMDD.md``) must agree
+  with the frontmatter ``idea`` field.
+
+API: ``validate_idea_brief(path) -> list[str]`` (empty list = valid).
+CLI: ``socratic-method validate <brief.md>``.
+"""
+
+from __future__ import annotations
+
+import datetime
+import json
+import re
+from importlib.resources import files
+from pathlib import Path
+
+import jsonschema
+import yaml
+
+_REQUIRED_HEADERS = (
+    "# Idea brief:",
+    "## What changed under questioning",
+    "## Scope",
+    "## Assumptions surfaced",
+    "## Contradictions & how resolved",
+    "## Open questions (aporia)",
+    "## Suggested next step",
+)
+
+_FILENAME_RE = re.compile(r"^(?P<slug>[a-z0-9][a-z0-9-]*)-(?P<date>\d{8})\.md$")
+
+
+def load_schema() -> dict:
+    """Load the packaged idea-brief-v1 JSON schema."""
+    raw = (
+        files("socratic_method")
+        .joinpath("assets/idea-brief-v1.schema.json")
+        .read_text(encoding="utf-8")
+    )
+    return json.loads(raw)
+
+
+def split_frontmatter(text: str) -> tuple[str | None, str]:
+    """Return (frontmatter_yaml, body), or (None, text) when no frontmatter block."""
+    if not text.startswith("---"):
+        return None, text
+    parts = text.split("\n---", 2)
+    if len(parts) < 2:
+        return None, text
+    return parts[0].removeprefix("---").strip("\n"), parts[1] + (parts[2] if len(parts) > 2 else "")
+
+
+def validate_idea_brief(brief_path: str | Path) -> list[str]:
+    """Return list of error strings. Empty list = valid."""
+    path = Path(brief_path)
+    errors: list[str] = []
+
+    try:
+        text = path.read_text(encoding="utf-8")
+    except OSError as e:
+        return [f"Read error: {e}"]
+
+    raw_fm, body = split_frontmatter(text)
+    if raw_fm is None:
+        return ["No YAML frontmatter block (file must start with ---)"]
+
+    try:
+        fm = yaml.safe_load(raw_fm)
+    except yaml.YAMLError as e:
+        return [f"Frontmatter YAML parse error: {e}"]
+    if not isinstance(fm, dict):
+        return ["Frontmatter is not a mapping"]
+
+    # YAML parses an unquoted 2026-07-04 as datetime.date; normalize before schema check.
+    if isinstance(fm.get("date"), datetime.date):
+        fm["date"] = fm["date"].isoformat()
+
+    try:
+        schema = load_schema()
+    except (OSError, json.JSONDecodeError) as e:
+        return [f"Schema load error: {e}"]
+    validator = jsonschema.Draft202012Validator(schema)
+    errors.extend(
+        f"frontmatter{'.' + '.'.join(str(p) for p in err.path) if err.path else ''}: {err.message}"
+        for err in sorted(validator.iter_errors(fm), key=lambda e: list(e.path))
+    )
+
+    for header in _REQUIRED_HEADERS:
+        if not any(line.startswith(header) for line in body.splitlines()):
+            errors.append(f"body: missing required header '{header}'")
+
+    if fm.get("verdict") == "refuted":
+        for i, claim in enumerate(fm.get("colliding_claims") or []):
+            if isinstance(claim, str) and claim not in body:
+                errors.append(
+                    f"colliding_claims[{i}]: not found verbatim in body — "
+                    "refutation must quote the colliding answers exactly"
+                )
+
+    m = _FILENAME_RE.match(path.name)
+    if m and isinstance(fm.get("idea"), str) and m.group("slug") != fm["idea"]:
+        errors.append(
+            f"filename slug '{m.group('slug')}' does not match frontmatter idea '{fm['idea']}'"
+        )
+
+    return errors

socratic_method-0.1.0.dist-info/METADATA

@@ -0,0 +1,170 @@
+Metadata-Version: 2.4
+Name: socratic-method
+Version: 0.1.0
+Summary: A Socratic questioning skill for coding agents (Claude Code, Codex, Copilot), with a one-command installer and an idea-brief validator.
+Project-URL: Homepage, https://github.com/grammy-jiang/socratic-method
+Project-URL: Issues, https://github.com/grammy-jiang/socratic-method/issues
+Author: Grammy Jiang
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agent-skills,claude-code,codex,copilot,socratic-method
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.11
+Requires-Dist: jsonschema>=4.0
+Requires-Dist: pyyaml>=6.0
+Description-Content-Type: text/markdown
+
+# socratic-method
+
+A **Socratic questioning skill for coding agents** — Claude Code, OpenAI Codex, and
+GitHub Copilot — packaged with a one-command installer and a deterministic artifact
+validator.
+
+Invoke the skill before real work starts (writing software, drafting a plan or document,
+making a decision) and the agent becomes a disciplined questioner: it steelmans your idea,
+interrogates it one question at a time (classic elenchus — six Socratic question types,
+counterexamples, contradiction-surfacing by quoting your own words), and ends with an
+honest verdict — **sharpened**, **aporia** (a genuinely unresolved hole, treated as a
+finding), or **refuted** (only ever out of your own mouth). The result is written down as
+a machine-validatable **idea brief** (`idea-brief-v1`) that downstream work can consume:
+open questions become a research agenda, unvalidated assumptions become a validation
+worklist.
+
+The skill was authored and hardened in
+[subagent-factory](https://github.com/grammy-jiang/subagent-factory): seven rounds of
+grounded review plus a six-cell adversarial behavioral eval (examiner vs. scripted user
+simulator, deterministic graders + independent judge), which caught and fixed real
+behavior gaps static review missed. The eval harness ships in this repo under `evals/`.
+
+## Install
+
+```bash
+pip install git+https://github.com/grammy-jiang/socratic-method
+# or, without installing:
+uvx --from git+https://github.com/grammy-jiang/socratic-method socratic-method --help
+```
+
+## Set up the skill for your agents
+
+```bash
+# auto-detect which agents are installed on this machine and configure those
+socratic-method setup
+
+# or name platforms explicitly / force all three
+socratic-method setup claude codex
+socratic-method setup all
+
+# install into your user home instead of the current project
+socratic-method setup claude --scope user
+
+# see what would happen first / check current state / remove
+socratic-method setup --dry-run
+socratic-method status
+socratic-method uninstall claude
+```
+
+With no targets, `setup` **auto-detects** installed agents and configures only those,
+printing the concrete evidence for each detection (never a bare claim):
+
+| Agent | Detection signals, in order |
+|---|---|
+| Claude Code | `claude` CLI on PATH; else `~/.claude/` config directory |
+| OpenAI Codex | `codex` CLI on PATH; else `~/.codex/` config directory |
+| GitHub Copilot | `copilot` CLI on PATH; else `gh-copilot` extension; else a `github.copilot*` VS Code extension |
+
+If nothing is detected, `setup` installs nothing and tells you how to name targets
+explicitly. `setup all` bypasses detection.
+
+`setup` is **idempotent** (content-hash comparison; an identical install reports
+"up to date"), refuses to overwrite locally modified files without `--force`, and after
+every write **reads the files back from disk before reporting success** — the skill's own
+"verify before claiming" rule, applied to its installer.
+
+### Where the skill lands
+
+| Platform | `--scope project` (default) | `--scope user` |
+|---|---|---|
+| Claude Code | `<root>/.claude/skills/socratic-method/` | `~/.claude/skills/socratic-method/` |
+| OpenAI Codex | `<root>/.agents/skills/socratic-method/` | `~/.agents/skills/socratic-method/` |
+| GitHub Copilot | `<root>/.github/skills/socratic-method/` | — |
+
+Copilot also reads a repo's `.claude/skills/`, so if the Claude project install is already
+present, the Copilot step reports "already covered" and skips (a duplicate would trigger
+twice); `--force` installs to `.github/skills/` anyway. Paths live in one data-driven
+registry (`installer.py`) — if a platform moves its skills directory, the fix is one line.
+
+## Use the skill
+
+In any agent with the skill installed:
+
+> stress-test this plan: …
+> help me think through …
+> poke holes in this idea: …
+
+Or invoke directly: `/socratic-method <idea> [--mode stress|develop] [--depth quick|standard|deep]`.
+The session ends with the brief saved to `notes/idea-briefs/<slug>-YYYYMMDD.md`.
+
+## Validate a brief
+
+```bash
+socratic-method validate notes/idea-briefs/my-idea-20260704.md
+```
+
+Checks the YAML frontmatter against the packaged `idea-brief-v1` JSON schema plus the
+cross-field rules a schema can't express (e.g. `verdict: refuted` requires the two
+colliding claims verbatim in the body; `verdict: aporia` requires open questions).
+
+## Behavioral eval harness (`evals/`)
+
+The six-cell regression matrix that hardened the skill: normal cells (planted
+contradiction → refuted; genuine unknowns → aporia; quick-depth cadence), edge cells
+(mid-session stop; disputed restatement), and an out-of-scope cell (fully specified plan →
+decline). Each cell runs a live examiner against a scripted user simulator, then grades
+the transcript with deterministic graders and an independent model judge.
+
+```bash
+python evals/run_eval.py --dry-run     # list cells, no calls
+python evals/run_eval.py --cell O1     # one cell
+python evals/run_eval.py               # full matrix — spawns ~30-60 headless `claude` calls
+```
+
+Requires the `claude` CLI and real tokens; run cells individually while iterating. A cell
+passes only when **all** deterministic graders pass AND the judge confirms the expected
+behavior with no fabrication.
+
+## Development
+
+```bash
+uv sync                      # or: pip install -e . && pip install pytest
+uv run pytest                # validator negatives, installer + detection behavior, CLI smoke
+uv run pre-commit install    # one tool per file type: ruff (py), syntax checks (yaml/json/toml), actionlint
+```
+
+CI (`.github/workflows/ci.yml`) runs the test suite on Python 3.11–3.13, builds the
+sdist/wheel, checks metadata, and smoke-tests the CLI installed from the built wheel.
+
+## Releasing to PyPI
+
+Publishing uses **PyPI Trusted Publishing** (OIDC) — no API token lives in the repo.
+One-time setup on pypi.org: *Account → Publishing → Add a new pending publisher* with
+project `socratic-method`, owner `grammy-jiang`, repository `socratic-method`, workflow
+`release.yml`, environment `pypi`. Then, to release:
+
+1. Bump `__version__` in `src/socratic_method/__init__.py`.
+2. Create a GitHub Release with tag `vX.Y.Z` (must match — the workflow verifies).
+3. `release.yml` builds, checks, and publishes; the package appears at
+   `pypi.org/project/socratic-method/`, after which `pip install socratic-method` works.
+
+Maintenance rule inherited from the skill's history: a behavioral failure is not fixed
+until something durable changes — a grader, a scenario, or a rail in `SKILL.md` — never a
+prose spot-fix alone.
+
+## License
+
+MIT

socratic_method-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+socratic_method/__init__.py,sha256=wxwvjw2VfqE6ikJq_8Y4UjhBIOwZnU01FcBFmZCwObY,495
+socratic_method/cli.py,sha256=YGWfrqMkIdTh8Bq61zi3cV-F-4u-DLY9XRdnaBYEK5M,5315
+socratic_method/installer.py,sha256=T9l9ASAvp-G9OdwhaKDS7PWmN8frFM1YV_P5QHzcAV4,9186
+socratic_method/validator.py,sha256=_YL-U0sAl05vUYei6rdgDpOichW3IWciYijoY8cFCW0,3880
+socratic_method/assets/SKILL.md,sha256=2mEJIbZPn1ke_8gIW7rfCMBm27qxF3IXQFQ7KKZ015w,14879
+socratic_method/assets/idea-brief-v1.schema.json,sha256=LC4BnrKVvi8PH8LMY5S3kgI6Zs3x8XIKhFwBFhDVsKQ,2894
+socratic_method/assets/references/example-session.md,sha256=GX8UDSPK9UshSb56O1xSBjJh1WArkoy5lJus3fRaH-4,7605
+socratic_method-0.1.0.dist-info/METADATA,sha256=98_OpKSwwfL83ZBTCamgrT0FOq8Sn8sClWSQO8_MUo4,7530
+socratic_method-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+socratic_method-0.1.0.dist-info/entry_points.txt,sha256=t5OsMhd77t_NZY95kBC99MlW9Ow4S6LpFYwKCC_9ztc,61
+socratic_method-0.1.0.dist-info/licenses/LICENSE,sha256=uFPMuBlmnrkl9sxXavhNpH6trppskKcU_5AN435lCr4,1069
+socratic_method-0.1.0.dist-info/RECORD,,

socratic_method-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

socratic_method-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+socratic-method = socratic_method.cli:main

socratic_method-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Grammy Jiang
+
+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.