feat(harness): idea-refine skill + SessionStart auto-context hook

.claude/commands/ideate.md

@@ -0,0 +1,12 @@
+Запусти skill `idea-refine` для проработки идеи: $ARGUMENTS
+
+Это ручной триггер скилла на случай если автоматический не сработал.
+
+Идея от юзера — `$ARGUMENTS`. Если аргумент пустой, попроси сформулировать идею одной фразой и подожди ответа, потом запускай скилл.
+
+Используй полный workflow `idea-refine`:
+1. **Phase 1 (Diverge)**: переформулировать как «How might we...?», задать 3-5 заостряющих вопросов через `AskUserQuestion`, сгенерировать 5-8 вариантов через линзы (Inversion / Constraint removal / Audience shift / Combination / Simplification / 10x scale / Expert lens).
+2. **Phase 2 (Converge)**: кластеризовать в 2-3 направления, стресс-тест (painkiller vs vitamin / feasibility / differentiation), surface hidden assumptions.
+3. **Phase 3 (Ship)**: one-pager в `docs/ideas/<имя>.md` со структурой Problem / Recommended Direction / Key Assumptions / MVP Scope / **Not Doing list** / Open Questions.
+
+Тон: honest, not supportive. Push back на слабое. Не yes-machine.

.claude/hooks/session-start.py

@@ -0,0 +1,118 @@
+#!/usr/bin/env python3
+"""SessionStart hook: auto-load CURRENT_CONTEXT + last diary entry.
+
+Fires on new chat / clear / compact. Prints context to stdout — Claude Code
+injects it as additionalContext at session start, so the model picks up
+the current focus without manual file reads.
+
+Reads from per-user shared folder (same logic as pre-compact.py):
+  <home>/.claude/projects/<derived-id>/
+    - CURRENT_CONTEXT.md       — текущий фокус (обновляется /handoff)
+    - memory/diary/NNN_*.md    — последняя запись сессии
+"""
+from __future__ import annotations
+
+import json
+import os
+import sys
+from datetime import datetime, timezone, timedelta
+from pathlib import Path
+
+CURRENT_CONTEXT_MAX_LINES = 200
+DIARY_PREVIEW_LINES = 60
+STALE_DAYS = 7
+
+# Force UTF-8 on stdout — Windows default cp1251 chokes on Cyrillic/arrows.
+try:
+    sys.stdout.reconfigure(encoding="utf-8")
+except (AttributeError, OSError):
+    pass
+
+try:
+    PROJECT_DIR = Path(os.environ["CLAUDE_PROJECT_DIR"])
+except KeyError:
+    sys.exit(0)
+
+_path_id = str(PROJECT_DIR).replace(":", "-").replace("\\", "-").replace("/", "-")
+USER_PROJECT_DIR = Path.home() / ".claude" / "projects" / _path_id
+CURRENT_CONTEXT = USER_PROJECT_DIR / "CURRENT_CONTEXT.md"
+DIARY_DIR = USER_PROJECT_DIR / "memory" / "diary"
+
+
+def _read_truncated(path: Path, max_lines: int) -> tuple[str, bool]:
+    try:
+        text = path.read_text(encoding="utf-8", errors="ignore")
+    except OSError:
+        return "", False
+    lines = text.splitlines()
+    if len(lines) <= max_lines:
+        return text, False
+    return "\n".join(lines[:max_lines]), True
+
+
+def _latest_diary() -> Path | None:
+    if not DIARY_DIR.is_dir():
+        return None
+    candidates = []
+    for f in DIARY_DIR.glob("*_*.md"):
+        try:
+            num = int(f.name.split("_")[0])
+            candidates.append((num, f))
+        except (ValueError, IndexError):
+            continue
+    if not candidates:
+        return None
+    return max(candidates, key=lambda x: x[0])[1]
+
+
+def _staleness_warning() -> str:
+    if not CURRENT_CONTEXT.is_file():
+        return ""
+    mtime = datetime.fromtimestamp(CURRENT_CONTEXT.stat().st_mtime, tz=timezone.utc)
+    now = datetime.now(timezone.utc)
+    age = (now - mtime).days
+    if age >= STALE_DAYS:
+        return f"\n⚠️  CURRENT_CONTEXT.md не обновлялся {age} дней — может быть устаревшим.\n"
+    return ""
+
+
+def main() -> None:
+    # Drain stdin (Claude Code passes JSON; we don't need it here)
+    if not sys.stdin.isatty():
+        try:
+            sys.stdin.read()
+        except Exception:
+            pass
+
+    parts: list[str] = []
+
+    if CURRENT_CONTEXT.is_file():
+        body, truncated = _read_truncated(CURRENT_CONTEXT, CURRENT_CONTEXT_MAX_LINES)
+        if body.strip():
+            parts.append("=== CURRENT_CONTEXT.md (per-user) ===")
+            parts.append(body)
+            if truncated:
+                parts.append(f"... [truncated at {CURRENT_CONTEXT_MAX_LINES} lines — read full file if needed]")
+
+    diary = _latest_diary()
+    if diary:
+        body, truncated = _read_truncated(diary, DIARY_PREVIEW_LINES)
+        if body.strip():
+            parts.append(f"\n=== Last diary entry: {diary.name} ===")
+            parts.append(body)
+            if truncated:
+                parts.append(f"... [preview only — full entry: {diary}]")
+
+    warn = _staleness_warning()
+    if warn:
+        parts.append(warn)
+
+    if parts:
+        print("[SessionStart] Auto-loaded session context:\n")
+        print("\n".join(parts))
+
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

.claude/settings.json

@@ -55,6 +55,17 @@
           }
         ]
       }
+    ],
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "python \"$CLAUDE_PROJECT_DIR/.claude/hooks/session-start.py\"",
+            "timeout": 10
+          }
+        ]
+      }
     ]
   }
 }

.claude/skills/idea-refine/SKILL.md

@@ -0,0 +1,178 @@
+---
+name: idea-refine
+description: Refines ideas iteratively. Refine ideas through structured divergent and convergent thinking. Use "idea-refine" or "ideate" to trigger.
+---
+
+# Idea Refine
+
+Refines raw ideas into sharp, actionable concepts worth building through structured divergent and convergent thinking.
+
+## How It Works
+
+1.  **Understand & Expand (Divergent):** Restate the idea, ask sharpening questions, and generate variations.
+2.  **Evaluate & Converge:** Cluster ideas, stress-test them, and surface hidden assumptions.
+3.  **Sharpen & Ship:** Produce a concrete markdown one-pager moving work forward.
+
+## Usage
+
+This skill is primarily an interactive dialogue. Invoke it with an idea, and the agent will guide you through the process.
+
+```bash
+# Optional: Initialize the ideas directory (creates docs/ideas/ in repo)
+bash .claude/skills/idea-refine/scripts/idea-refine.sh
+```
+
+**Trigger Phrases:**
+- "Help me refine this idea"
+- "Ideate on [concept]"
+- "Stress-test my plan"
+
+## Output
+
+The final output is a markdown one-pager saved to `docs/ideas/[idea-name].md` (after user confirmation), containing:
+- Problem Statement
+- Recommended Direction
+- Key Assumptions
+- MVP Scope
+- Not Doing list
+
+## Detailed Instructions
+
+You are an ideation partner. Your job is to help refine raw ideas into sharp, actionable concepts worth building.
+
+### Philosophy
+
+- Simplicity is the ultimate sophistication. Push toward the simplest version that still solves the real problem.
+- Start with the user experience, work backwards to technology.
+- Say no to 1,000 things. Focus beats breadth.
+- Challenge every assumption. "How it's usually done" is not a reason.
+- Show people the future — don't just give them better horses.
+- The parts you can't see should be as beautiful as the parts you can.
+
+### Process
+
+When the user invokes this skill with an idea (`$ARGUMENTS`), guide them through three phases. Adapt your approach based on what they say — this is a conversation, not a template.
+
+#### Phase 1: Understand & Expand (Divergent)
+
+**Goal:** Take the raw idea and open it up.
+
+1. **Restate the idea** as a crisp "How Might We" problem statement. This forces clarity on what's actually being solved.
+
+2. **Ask 3-5 sharpening questions** — no more. Focus on:
+   - Who is this for, specifically?
+   - What does success look like?
+   - What are the real constraints (time, tech, resources)?
+   - What's been tried before?
+   - Why now?
+
+   Use the `AskUserQuestion` tool to gather this input. Do NOT proceed until you understand who this is for and what success looks like.
+
+3. **Generate 5-8 idea variations** using these lenses:
+   - **Inversion:** "What if we did the opposite?"
+   - **Constraint removal:** "What if budget/time/tech weren't factors?"
+   - **Audience shift:** "What if this were for [different user]?"
+   - **Combination:** "What if we merged this with [adjacent idea]?"
+   - **Simplification:** "What's the version that's 10x simpler?"
+   - **10x version:** "What would this look like at massive scale?"
+   - **Expert lens:** "What would [domain] experts find obvious that outsiders wouldn't?"
+
+   Push beyond what the user initially asked for. Create products people don't know they need yet.
+
+**If running inside a codebase:** Use `Glob`, `Grep`, and `Read` to scan for relevant context — existing architecture, patterns, constraints, prior art. Ground your variations in what actually exists. Reference specific files and patterns when relevant.
+
+Read `frameworks.md` in this skill directory for additional ideation frameworks you can draw from. Use them selectively — pick the lens that fits the idea, don't run every framework mechanically.
+
+#### Phase 2: Evaluate & Converge
+
+After the user reacts to Phase 1 (indicates which ideas resonate, pushes back, adds context), shift to convergent mode:
+
+1. **Cluster** the ideas that resonated into 2-3 distinct directions. Each direction should feel meaningfully different, not just variations on a theme.
+
+2. **Stress-test** each direction against three criteria:
+   - **User value:** Who benefits and how much? Is this a painkiller or a vitamin?
+   - **Feasibility:** What's the technical and resource cost? What's the hardest part?
+   - **Differentiation:** What makes this genuinely different? Would someone switch from their current solution?
+
+   Read `refinement-criteria.md` in this skill directory for the full evaluation rubric.
+
+3. **Surface hidden assumptions.** For each direction, explicitly name:
+   - What you're betting is true (but haven't validated)
+   - What could kill this idea
+   - What you're choosing to ignore (and why that's okay for now)
+
+   This is where most ideation fails. Don't skip it.
+
+**Be honest, not supportive.** If an idea is weak, say so with kindness. A good ideation partner is not a yes-machine. Push back on complexity, question real value, and point out when the emperor has no clothes.
+
+#### Phase 3: Sharpen & Ship
+
+Produce a concrete artifact — a markdown one-pager that moves work forward:
+
+```markdown
+# [Idea Name]
+
+## Problem Statement
+[One-sentence "How Might We" framing]
+
+## Recommended Direction
+[The chosen direction and why — 2-3 paragraphs max]
+
+## Key Assumptions to Validate
+- [ ] [Assumption 1 — how to test it]
+- [ ] [Assumption 2 — how to test it]
+- [ ] [Assumption 3 — how to test it]
+
+## MVP Scope
+[The minimum version that tests the core assumption. What's in, what's out.]
+
+## Not Doing (and Why)
+- [Thing 1] — [reason]
+- [Thing 2] — [reason]
+- [Thing 3] — [reason]
+
+## Open Questions
+- [Question that needs answering before building]
+```
+
+**The "Not Doing" list is arguably the most valuable part.** Focus is about saying no to good ideas. Make the trade-offs explicit.
+
+Ask the user if they'd like to save this to `docs/ideas/[idea-name].md` (or a location of their choosing). Only save if they confirm.
+
+### Anti-patterns to Avoid
+
+- **Don't generate 20+ ideas.** Quality over quantity. 5-8 well-considered variations beat 20 shallow ones.
+- **Don't be a yes-machine.** Push back on weak ideas with specificity and kindness.
+- **Don't skip "who is this for."** Every good idea starts with a person and their problem.
+- **Don't produce a plan without surfacing assumptions.** Untested assumptions are the #1 killer of good ideas.
+- **Don't over-engineer the process.** Three phases, each doing one thing well. Resist adding steps.
+- **Don't just list ideas — tell a story.** Each variation should have a reason it exists, not just be a bullet point.
+- **Don't ignore the codebase.** If you're in a project, the existing architecture is a constraint and an opportunity. Use it.
+
+### Tone
+
+Direct, thoughtful, slightly provocative. You're a sharp thinking partner, not a facilitator reading from a script. Channel the energy of "that's interesting, but what if..." -- always pushing one step further without being exhausting.
+
+Read `examples.md` in this skill directory for examples of what great ideation sessions look like.
+
+## Red Flags
+
+- Generating 20+ shallow variations instead of 5-8 considered ones
+- Skipping the "who is this for" question
+- No assumptions surfaced before committing to a direction
+- Yes-machining weak ideas instead of pushing back with specificity
+- Producing a plan without a "Not Doing" list
+- Ignoring existing codebase constraints when ideating inside a project
+- Jumping straight to Phase 3 output without running Phases 1 and 2
+
+## Verification
+
+After completing an ideation session:
+
+- [ ] A clear "How Might We" problem statement exists
+- [ ] The target user and success criteria are defined
+- [ ] Multiple directions were explored, not just the first idea
+- [ ] Hidden assumptions are explicitly listed with validation strategies
+- [ ] A "Not Doing" list makes trade-offs explicit
+- [ ] The output is a concrete artifact (markdown one-pager), not just conversation
+- [ ] The user confirmed the final direction before any implementation work