Skill Studio

{
  "name": "skill-studio",
  "description": "Interview-driven automation design tool. This skill should be used when the user wants to design a new skill, agent, aut",
  "author": {
    "name": "Gleb Kalinin"
  },
  "repository": "https://github.com/glebis/claude-skills",
  "license": "MIT"
}

# skill-studio environment overrides. Copy to a private location outside
# the repo and point $SKILL_STUDIO_ENV_FILE at the encrypted version, or
# source this file directly for local development.

# --- Paths (all optional; defaults shown) ---
# SKILL_STUDIO_HOME=~/.skill-studio
# SKILL_STUDIO_ENV_FILE=~/.env.skill-studio
# SKILL_STUDIO_PIPECAT_ENV=~/.env.pipecat
# SKILL_STUDIO_IMPORT_ENV=
# SKILL_STUDIO_GROUNDWORK_ROOT=

# --- LLM provider ---
LLM_PROVIDER=openrouter
OPENROUTER_MODEL=anthropic/claude-opus-4
OPENROUTER_API_KEY=
# ANTHROPIC_API_KEY=

# --- Voice mode (optional; only needed for --voice) ---
DAILY_API_KEY=
GROQ_API_KEY=
DEEPGRAM_API_KEY=
DEEPGRAM_VOICE=aura-asteria-en

# --- Debug ---
# SKILL_STUDIO_QUIET=1

# Python
__pycache__/
*.py[cod]
*$py.class
*.so
*.egg
*.egg-info/
dist/
build/
develop-eggs/
eggs/
.eggs/
sdist/
wheels/
share/python-wheels/

# Virtual environments
.venv/
venv/
env/
ENV/

# Test / coverage
.pytest_cache/
.coverage
.coverage.*
htmlcov/
.tox/
.cache/
coverage.xml
*.cover

# Editors / OS
.idea/
.vscode/
*.swp
*.swo
.DS_Store

# Secrets — never commit plaintext or encrypted provider keys
.env
.env.*
!.env.example
.env.skill-studio
.env.pipecat

# User data (default location outside repo, but guard anyway)
.skill-studio/
sessions/

# Logs
*.log

# Enzyme local cache
.enzyme/
.enzyme-embeddings/

# {{ design.hook or "Untitled Design" }}

{% if design.problem.what_hurts -%}
## The Problem

{{ design.problem.what_hurts }}
{% if design.problem.cost_today %}*Cost today:* {{ design.problem.cost_today }}{% endif %}
{%- endif %}

## Job to be Done

**When** {{ design.jtbd.situation }}, **I want to** {{ design.jtbd.motivation }}, **so I can** {{ design.jtbd.outcome }}.

{% if design.meta.jtbd_frame == "forces" and design.jtbd_frame_extension -%}
### Forces of Progress

- **Push** (current pain): {{ design.jtbd_frame_extension.push or "—" }}
- **Pull** (new promise): {{ design.jtbd_frame_extension.pull or "—" }}
- **Anxiety**: {{ design.jtbd_frame_extension.anxiety or "—" }}
- **Habit**: {{ design.jtbd_frame_extension.habit or "—" }}
{%- endif %}

## Before / After

|        | Before                                            | After                                             |
|--------|---------------------------------------------------|---------------------------------------------------|
| Seen   | {{ design.before_after.before_external or "—" }}  | {{ design.before_after.after_external or "—" }}   |
| Felt   | {{ design.before_after.before_internal or "—" }}  | {{ design.before_after.after_internal or "—" }}   |

{% if design.scenarios -%}
## Scenarios

{% for s in design.scenarios -%}
> **{{ s.title }}** — {{ s.vignette }}

{% endfor %}
{%- endif %}

## Under the hood

- **Trigger:** {{ design.trigger.type }} — {{ design.trigger.detail or "(tbd)" }}
- **Inputs:** {{ design.inputs | join(", ") or "—" }}
- **Capabilities:** {{ design.capabilities | join(", ") or "—" }}
- **Outputs:** {{ design.outputs | join(", ") or "—" }}
- **Guardrails:** {{ design.guardrails | join(", ") or "—" }}

{% if design.cta %}## Next step

{{ design.cta }}
{% endif %}

---
*session id:* `{{ design.meta.id }}` — *generated by skill-studio*

<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1200 900" width="1200" height="900" font-family="system-ui, sans-serif">
  <defs>
    <filter id="organic" x="-10%" y="-10%" width="120%" height="120%">
      <feTurbulence type="fractalNoise" baseFrequency="0.02" numOctaves="2" seed="4"/>
      <feDisplacementMap in="SourceGraphic" scale="4"/>
    </filter>
  </defs>

  <rect width="1200" height="900" fill="#fafaf7"/>

  <g transform="translate(600,200)">
    <ellipse cx="0" cy="0" rx="260" ry="90" fill="#111" filter="url(#organic)"/>
    <text text-anchor="middle" fill="#fafaf7" font-size="22" font-weight="600" dy="6">
      {{ design.hook[:60] or "Untitled" }}
    </text>
  </g>

  <g transform="translate(600,340)">
    <text text-anchor="middle" fill="#555" font-size="14">
      When {{ design.jtbd.situation[:40] }}
    </text>
    <text text-anchor="middle" fill="#111" font-size="16" dy="20" font-weight="500">
      I want to {{ design.jtbd.motivation[:50] }}
    </text>
    <text text-anchor="middle" fill="#555" font-size="14" dy="40">
      so I can {{ design.jtbd.outcome[:40] }}
    </text>
  </g>

  {% set grid_y = 450 %}
  <g transform="translate(100,{{ grid_y }})">
    <text x="0" y="-10" fill="#555" font-size="14" font-weight="600">BEFORE (seen)</text>
    <text x="480" y="-10" fill="#555" font-size="14" font-weight="600">AFTER (seen)</text>
    <text x="0" y="140" fill="#555" font-size="14" font-weight="600">BEFORE (felt)</text>
    <text x="480" y="140" fill="#555" font-size="14" font-weight="600">AFTER (felt)</text>
    <rect x="0" y="0" width="440" height="110" fill="none" stroke="#ccc" stroke-width="1" rx="14"/>
    <rect x="480" y="0" width="440" height="110" fill="none" stroke="#ccc" stroke-width="1" rx="14"/>
    <rect x="0" y="150" width="440" height="110" fill="none" stroke="#ccc" stroke-width="1" rx="14"/>
    <rect x="480" y="150" width="440" height="110" fill="none" stroke="#ccc" stroke-width="1" rx="14"/>
    <foreignObject x="12" y="12" width="416" height="90">
      <div xmlns="http://www.w3.org/1999/xhtml" style="font-size:14px; color:#222;">
        {{ design.before_after.before_external[:200] or "—" }}
      </div>
    </foreignObject>
    <foreignObject x="492" y="12" width="416" height="90">
      <div xmlns="http://www.w3.org/1999/xhtml" style="font-size:14px; color:#222;">
        {{ design.before_after.after_external[:200] or "—" }}
      </div>
    </foreignObject>
    <foreignObject x="12" y="162" width="416" height="90">
      <div xmlns="http://www.w3.org/1999/xhtml" style="font-size:14px; color:#222;">
        {{ design.before_after.before_internal[:200] or "—" }}
      </div>
    </foreignObject>
    <foreignObject x="492" y="162" width="416" height="90">
      <div xmlns="http://www.w3.org/1999/xhtml" style="font-size:14px; color:#222;">
        {{ design.before_after.after_internal[:200] or "—" }}
      </div>
    </foreignObject>
  </g>

  <g transform="translate(1020,200)">
    <text x="0" y="0" fill="#111" font-size="13" font-weight="600">TRIGGER</text>
    <text x="0" y="18" fill="#555" font-size="12">{{ design.trigger.type }}: {{ design.trigger.detail[:30] or "—" }}</text>
    <text x="0" y="60" fill="#111" font-size="13" font-weight="600">INPUTS</text>
    {% for i in design.inputs[:4] %}<text x="0" y="{{ 78 + loop.index0 * 14 }}" fill="#555" font-size="12">· {{ i[:30] }}</text>{% endfor %}
    <text x="0" y="180" fill="#111" font-size="13" font-weight="600">OUTPUTS</text>
    {% for o in design.outputs[:4] %}<text x="0" y="{{ 198 + loop.index0 * 14 }}" fill="#555" font-size="12">· {{ o[:30] }}</text>{% endfor %}
  </g>

  {% if design.scenarios %}
  <g transform="translate(100,760)">
    <text x="0" y="0" fill="#111" font-size="13" font-weight="600">SCENARIO</text>
    <text x="0" y="20" fill="#222" font-size="14" font-style="italic">{{ design.scenarios[0].title }}</text>
    <foreignObject x="0" y="28" width="1000" height="90">
      <div xmlns="http://www.w3.org/1999/xhtml" style="font-size:14px; color:#333;">
        {{ design.scenarios[0].vignette[:400] }}
      </div>
    </foreignObject>
  </g>
  {% endif %}

  <text x="1180" y="880" text-anchor="end" fill="#999" font-size="10">skill-studio · {{ design.meta.id[:8] }}</text>
</svg>

MIT License

Copyright (c) 2026 skill-studio contributors

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.

[project]
name = "skill-studio"
version = "0.1.0"
description = "Interview-driven automation design tool — conducts a JTBD interview (text or voice) and exports a one-page design spec plus an SVG map."
readme = "README.md"
license = { file = "LICENSE" }
authors = [
    { name = "skill-studio contributors" },
]
requires-python = ">=3.11"
keywords = ["jtbd", "interview", "design", "skill", "claude-code", "automation", "voice"]
classifiers = [
    "Development Status :: 4 - Beta",
    "Environment :: Console",
    "Intended Audience :: Developers",
    "License :: OSI Approved :: MIT License",
    "Operating System :: POSIX",
    "Operating System :: MacOS",
    "Programming Language :: Python :: 3",
    "Programming Language :: Python :: 3.11",
    "Programming Language :: Python :: 3.12",
    "Programming Language :: Python :: 3.13",
    "Topic :: Software Development",
    "Topic :: Software Development :: Libraries :: Application Frameworks",
]
dependencies = [
    "anthropic>=0.40",
    "openai>=1.40",
    "pydantic>=2.0",
    "pyyaml>=6.0",
    "jinja2>=3.1",
    "loguru>=0.7",
    "pipecat-ai>=1.0.0",
]

[project.optional-dependencies]
test = ["pytest>=8.0", "pytest-mock>=3.12", "coverage>=7.0"]

[project.urls]
Homepage = "https://github.com/glebis/skill-studio"
Issues = "https://github.com/glebis/skill-studio/issues"
Repository = "https://github.com/glebis/skill-studio.git"

[project.scripts]
skill-studio = "skill_studio.cli:main"

[build-system]
requires = ["setuptools>=68"]
build-backend = "setuptools.build_meta"

[tool.setuptools.packages.find]
where = ["src"]

[tool.setuptools.package-data]
skill_studio = ["presets/*.yaml", "interview/frameworks/*.yaml", "../assets/*.j2"]

# requirements.txt — pinned runtime deps
anthropic==0.40.0
openai>=1.40
pydantic==2.9.2
pyyaml==6.0.2
jinja2==3.1.4
pipecat-ai==0.0.50

# DEPRECATED: Use skill_studio.llm_provider.get_provider() instead.
# Kept for backwards compatibility only.
from __future__ import annotations
from typing import Any
import os
from anthropic import Anthropic


MODEL_DEFAULT = "claude-opus-4-7"


class AnthropicInterviewer:
    def __init__(self, system_prompt: str, client: Any | None = None, model: str = MODEL_DEFAULT):
        self.client = client or Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])
        self.model = model
        self.system_prompt = system_prompt

    def ask(self, history: list[dict], max_tokens: int = 600) -> str:
        resp = self.client.messages.create(
            model=self.model,
            max_tokens=max_tokens,
            system=[{
                "type": "text",
                "text": self.system_prompt,
                "cache_control": {"type": "ephemeral"},
            }],
            messages=history,
        )
        for block in resp.content:
            if getattr(block, "text", None):
                return block.text
        return ""

from __future__ import annotations
import argparse
import json
import sys
from pathlib import Path

from skill_studio.storage import SessionStorage
from skill_studio.presets import load_preset, list_presets
from skill_studio.interview.loop import run_interview_turn
from skill_studio.interview.modes import QUESTION_BUDGET, COVERAGE_THRESHOLD
from skill_studio.interview.updater import _deep_merge
from skill_studio.interview.coverage import overall_coverage, next_uncovered_field, score_coverage
from skill_studio.exporters.registry import get_exporter
from skill_studio.llm_provider import get_provider
from skill_studio import paths


SESSION_ROOT = paths.session_root()


def find_resumable(storage: SessionStorage):
    """Return most recent session whose coverage is below its depth-mode threshold, or None."""
    sessions = storage.list()
    sessions.sort(key=lambda s: s.meta.created, reverse=True)
    for s in sessions:
        try:
            preset = load_preset(s.meta.preset)
        except ValueError:
            continue
        threshold = COVERAGE_THRESHOLD.get(s.meta.interview_mode.depth, 0.8)
        if overall_coverage(s, preset) < threshold:
            return s
    return None


def resolve_session(args: argparse.Namespace, storage: SessionStorage):
    """Return (design, resumed_bool). Auto-resume unless --fresh or --resume given."""
    if getattr(args, "resume", None):
        return storage.load(args.resume), True
    if not getattr(args, "fresh", False):
        candidate = find_resumable(storage)
        if candidate is not None:
            return candidate, True
    design = storage.new()
    design.meta.preset = args.preset
    design.meta.interview_mode.depth = args.depth
    design.meta.interview_mode.style = args.style
    storage.save(design)
    return design, False


# ---------------------------------------------------------------------------
# Original stdin-loop fallback (now uses provider factory instead of hardcoded Anthropic)
# ---------------------------------------------------------------------------

def cmd_new(args: argparse.Namespace) -> int:
    storage = SessionStorage(SESSION_ROOT)
    design, resumed = resolve_session(args, storage)
    preset = load_preset(design.meta.preset)
    if resumed:
        cov = overall_coverage(design, preset)
        print(f"Resuming session {design.meta.id[:8]} ({cov:.0%} covered)")

    provider = get_provider(system_prompt=preset.opening_question)
    budget = QUESTION_BUDGET[args.depth]
    question = run_interview_turn(design, preset, provider, user_input=None)
    storage.append_transcript(design.meta.id, "assistant", question)
    print(f"\n{question}\n")

    asked = 1
    while asked < budget:
        try:
            user_input = input("you> ").strip()
        except EOFError:
            break
        if not user_input or user_input.lower() in {"done", "wrap up", "stop"}:
            break
        storage.append_transcript(design.meta.id, "user", user_input)
        question = run_interview_turn(design, preset, provider, user_input=user_input)
        storage.append_transcript(design.meta.id, "assistant", question)
        print(f"\n{question}\n")
        asked += 1
        storage.save(design)

    exporter = get_exporter("md-svg")
    out = SESSION_ROOT / design.meta.id
    exporter.render(design, out)
    print(f"\nDone. Session id: {design.meta.id}")
    print(f"Files: {out}")
    return 0


# ---------------------------------------------------------------------------
# State-only CLI subcommands (used by Claude Code-native interview)
# ---------------------------------------------------------------------------

def cmd_new_session(args: argparse.Namespace) -> int:
    """Create a session, print session_id and opening question. No LLM calls."""
    storage = SessionStorage(SESSION_ROOT)
    preset = load_preset(args.preset)
    design = storage.new()
    design.meta.preset = args.preset
    design.meta.interview_mode.depth = args.depth
    design.meta.interview_mode.style = args.style
    storage.save(design)
    print(f"session_id: {design.meta.id}")
    print(f"opening: {preset.opening_question}")
    return 0


def cmd_apply_patch(args: argparse.Namespace) -> int:
    """Read JSON patch from stdin, apply to design, print updated coverage + next_target."""
    storage = SessionStorage(SESSION_ROOT)
    design = storage.load(args.id)
    preset = load_preset(design.meta.preset)

    raw = sys.stdin.read().strip()
    if raw:
        try:
            patch = json.loads(raw)
        except json.JSONDecodeError as exc:
            print(f"error: invalid JSON patch: {exc}", file=sys.stderr)
            return 1
        if isinstance(patch, dict):
            _deep_merge(design, patch)
            storage.save(design)

    cov = overall_coverage(design, preset)
    nxt = next_uncovered_field(design, preset) or "DONE"
    print(f"coverage: {cov:.2f}")
    print(f"next_target: {nxt}")
    return 0


def cmd_next_target(args: argparse.Namespace) -> int:
    """Print the next uncovered field path, or DONE."""
    storage = SessionStorage(SESSION_ROOT)
    design = storage.load(args.id)
    preset = load_preset(design.meta.preset)
    nxt = next_uncovered_field(design, preset)
    print(nxt if nxt else "DONE")
    return 0


def cmd_coverage(args: argparse.Namespace) -> int:
    """Print overall coverage + per-field scores as JSON."""
    storage = SessionStorage(SESSION_ROOT)
    design = storage.load(args.id)
    preset = load_preset(design.meta.preset)
    scores = score_coverage(design)
    cov = overall_coverage(design, preset)
    print(json.dumps({"overall": round(cov, 4), "fields": {k: round(v, 4) for k, v in scores.items()}}, indent=2))
    return 0


def cmd_done(args: argparse.Namespace) -> int:
    """Export design.md + design.svg for a session and print the paths."""
    storage = SessionStorage(SESSION_ROOT)
    design = storage.load(args.id)
    exporter = get_exporter("md-svg")
    out_dir = SESSION_ROOT / args.id
    paths = exporter.render(design, out_dir)
    for p in paths:
        print(f"wrote {p}")
    return 0


# ---------------------------------------------------------------------------
# Existing subcommands
# ---------------------------------------------------------------------------

def cmd_list(args: argparse.Namespace) -> int:
    storage = SessionStorage(SESSION_ROOT)
    for s in storage.list():
        print(f"{s.meta.id[:8]}  preset={s.meta.preset}  hook={s.hook[:60]}")
    return 0


def cmd_export(args: argparse.Namespace) -> int:
    storage = SessionStorage(SESSION_ROOT)
    design = storage.load(args.id)
    exporter = get_exporter(args.target)
    paths = exporter.render(design, SESSION_ROOT / args.id)
    for p in paths:
        print(f"wrote {p}")
    return 0


def cmd_setup(args: argparse.Namespace) -> int:
    from skill_studio.setup import run_setup
    run_setup()
    return 0


def cmd_init(args: argparse.Namespace) -> int:
    from skill_studio.init_wizard import run_init_wizard
    return run_init_wizard()


def cmd_propose_from_session(args: argparse.Namespace) -> int:
    """Ingest a prior session (deterministic) + propose a DesignJSON patch (one LLM call).

    Does NOT apply the patch. Caller (Claude Code) shows the proposal to the
    user, collects approval/edits, then pipes the approved patch to apply-patch.
    """
    import sys
    from skill_studio.ingest.transcript import (
        extract, resolve_session, resolve_current_session,
    )
    from skill_studio.ingest.proposer import propose
    from pathlib import Path as _P

    project = getattr(args, "project", None)

    if args.path:
        path = _P(args.path).expanduser()
        source = "path"
        session_id = args.session_id or path.stem
    elif getattr(args, "current", False):
        path, session_id = resolve_current_session(project=project)
        source = "claude-code"
    else:
        if not args.session_id:
            print("error: provide a session_id, --current, or --path", file=sys.stderr)
            return 1
        path, source = resolve_session(args.session_id, project=project)
        session_id = args.session_id

    bundle = extract(path, session_id, source)
    if args.bundle_only:
        json.dump(bundle.to_dict(), sys.stdout, indent=2)
        sys.stdout.write("\n")
        return 0

    provider = get_provider(system_prompt="You are a JTBD interview seeder.")
    patch, rationale = propose(bundle, provider)
    out = {
        "bundle_summary": bundle.to_dict().get("summary"),
        "patch": patch,
        "rationale": rationale,
    }
    json.dump(out, sys.stdout, indent=2)
    sys.stdout.write("\n")
    return 0


def cmd_list_sessions(args: argparse.Namespace) -> int:
    """List Claude Code sessions, optionally filtered by project."""
    from skill_studio.ingest.transcript import list_claude_code_sessions
    import time

    project = getattr(args, "project", None)
    limit = getattr(args, "limit", 20)
    sessions = list_claude_code_sessions(project=project, limit=limit)
    if not sessions:
        print("No sessions found.")
        return 0
    for s in sessions:
        age = time.time() - s["modified"]
        if age < 3600:
            age_str = f"{int(age / 60)}m ago"
        elif age < 86400:
            age_str = f"{int(age / 3600)}h ago"
        else:
            age_str = f"{int(age / 86400)}d ago"
        title = s["title"][:50] if s["title"] else "(untitled)"
        print(f"{s['session_id'][:8]}  {age_str:>8}  {s['size_kb']:>7.1f}kb  {title}")
    return 0


def main(argv: list[str] | None = None) -> int:
    parser = argparse.ArgumentParser(prog="skill-studio")
    sub = parser.add_subparsers(dest="cmd", required=True)

    # --- new (stdin fallback) ---
    new_p = sub.add_parser("new")
    new_p.add_argument("--preset", choices=list_presets(), default="custom")
    new_p.add_argument("--depth", choices=["sprint", "standard", "deep"], default="standard")
    new_p.add_argument("--style", choices=["socratic", "scenario-first", "metaphor-first", "form", "conversational"], default="scenario-first")
    new_p.add_argument("--voice", action="store_true")
    new_p.add_argument("--resume", metavar="ID", help="Resume a specific session id")
    new_p.add_argument("--fresh", action="store_true", help="Force new session even if a resumable one exists")
    new_p.set_defaults(func=cmd_new)

    # --- new-session (state-only) ---
    ns_p = sub.add_parser("new-session")
    ns_p.add_argument("--preset", choices=list_presets(), default="custom")
    ns_p.add_argument("--depth", choices=["sprint", "standard", "deep"], default="standard")
    ns_p.add_argument("--style", choices=["socratic", "scenario-first", "metaphor-first", "form", "conversational"], default="scenario-first")
    ns_p.set_defaults(func=cmd_new_session)

    # --- apply-patch ---
    ap_p = sub.add_parser("apply-patch")
    ap_p.add_argument("id")
    ap_p.set_defaults(func=cmd_apply_patch)

    # --- next-target ---
    nt_p = sub.add_parser("next-target")
    nt_p.add_argument("id")
    nt_p.set_defaults(func=cmd_next_target)

    # --- coverage ---
    cov_p = sub.add_parser("coverage")
    cov_p.add_argument("id")
    cov_p.set_defaults(func=cmd_coverage)

    # --- done ---
    done_p = sub.add_parser("done")
    done_p.add_argument("id")
    done_p.set_defaults(func=cmd_done)

    # --- list ---
    list_p = sub.add_parser("list")
    list_p.set_defaults(func=cmd_list)

    # --- export ---
    export_p = sub.add_parser("export")
    export_p.add_argument("id")
    export_p.add_argument("target")
    export_p.set_defaults(func=cmd_export)

    # --- setup (key-entry only, sops-required) ---
    setup_p = sub.add_parser("setup")
    setup_p.set_defaults(func=cmd_setup)

    # --- init (full first-run wizard) ---
    init_p = sub.add_parser("init", help="Interactive first-run setup wizard")
    init_p.set_defaults(func=cmd_init)

    # --- propose-from-session (ingest a prior transcript → JTBD patch proposal) ---
    pfs_p = sub.add_parser(
        "propose-from-session",
        help="Ingest a prior session and propose a DesignJSON patch (user must approve before apply-patch)",
    )
    pfs_p.add_argument("session_id", nargs="?")
    pfs_p.add_argument("--current", action="store_true",
                        help="Use the current running Claude Code session (via CLAUDE_CODE_SESSION_ID)")
    pfs_p.add_argument("--project", help="Scope search to a specific project directory name")
    pfs_p.add_argument("--path", help="Direct path to a transcript file")
    pfs_p.add_argument(
        "--bundle-only",
        action="store_true",
        help="Emit just the deterministic bundle (no LLM call)",
    )
    pfs_p.set_defaults(func=cmd_propose_from_session)

    # --- list-sessions (show Claude Code sessions) ---
    ls_p = sub.add_parser(
        "list-sessions",
        help="List Claude Code sessions (most recent first)",
    )
    ls_p.add_argument("--project", help="Filter by project directory name")
    ls_p.add_argument("--limit", type=int, default=20, help="Max sessions to show (default: 20)")
    ls_p.set_defaults(func=cmd_list_sessions)

    args = parser.parse_args(argv)
    if args.cmd == "new" and getattr(args, "voice", False):
        from skill_studio.voice.pipecat_interview import run_voice_interview
        return run_voice_interview(args)
    return args.func(args)


if __name__ == "__main__":
    sys.exit(main())

from __future__ import annotations
from pathlib import Path
from typing import Protocol
from skill_studio.schema import DesignJSON


class Exporter(Protocol):
    name: str

    def render(self, design: DesignJSON, out_dir: Path) -> list[Path]: ...

from __future__ import annotations
from pathlib import Path
from jinja2 import Environment, FileSystemLoader, select_autoescape
from skill_studio.schema import DesignJSON


TEMPLATE_DIR = Path(__file__).resolve().parents[2].parent / "assets"


class MdSvgExporter:
    name = "md-svg"

    def __init__(self, template_dir: Path = TEMPLATE_DIR):
        self.env = Environment(
            loader=FileSystemLoader(str(template_dir)),
            autoescape=select_autoescape(["html", "svg"]),
            keep_trailing_newline=True,
        )

    def render(self, design: DesignJSON, out_dir: Path) -> list[Path]:
        out_dir.mkdir(parents=True, exist_ok=True)
        md = self.env.get_template("design.md.j2").render(design=design)
        svg = self.env.get_template("design.svg.j2").render(design=design)
        md_path = out_dir / "design.md"
        svg_path = out_dir / "design.svg"
        md_path.write_text(md)
        svg_path.write_text(svg)
        return [md_path, svg_path]

from __future__ import annotations
from skill_studio.exporters.base import Exporter
from skill_studio.exporters.md_svg import MdSvgExporter


EXPORTERS: dict[str, Exporter] = {
    "md-svg": MdSvgExporter(),
}


def get_exporter(name: str) -> Exporter:
    if name not in EXPORTERS:
        raise KeyError(f"Unknown exporter: {name}. Available: {sorted(EXPORTERS)}")
    return EXPORTERS[name]

"""Turn an ingest Bundle into a proposed DesignJSON patch (single LLM call).

Flow: Bundle (deterministic) -> proposer (one LLM call) -> partial JSON patch.
The patch is NOT applied; the caller must present it to the user for approval.
"""
from __future__ import annotations
import json
from typing import Protocol

from .transcript import Bundle


class LLMProvider(Protocol):
    def ask(self, history: list[dict], max_tokens: int = ...) -> str: ...


PROPOSE_PROMPT = """You are helping seed a JTBD interview from a compact bundle of signals \
extracted from a prior session. Propose initial values for the DesignJSON schema below, \
using ONLY what the signals support. When uncertain, leave the field empty — do not \
hallucinate. The user will review and approve/edit before anything is applied.

Schema (propose only fields the signals justify):
  hook (str), problem.what_hurts (str), problem.cost_today (str),
  jtbd.situation (str), jtbd.motivation (str), jtbd.outcome (str),
  scenarios (list of {title, vignette}),
  capabilities (list), inputs (list)

The bundle now includes structured session activity:
- agents: subagent calls with descriptions, types, and prompt snippets
- skills: skill invocations observed during the session
- tool_sequence: ordered list of all tool calls with descriptions
- tool_frequency: how often each tool was used
- workflow_patterns: repeated tool sequences (potential automatable workflows)

Use these signals to infer capabilities, inputs, and scenarios. For example:
- Agent calls reveal delegation patterns and multi-step orchestration
- Skill calls show existing automations the user relies on
- Workflow patterns (repeated tool sequences) suggest automatable workflows
- Tool frequency reveals the user's primary interaction patterns

Rules:
- Every proposed value must cite which signal it came from in the "rationale" map.
- If the bundle is empty/thin, propose {} — do not invent.
- cost_today: only fill if total_cost_usd > 0 or the transcript clearly complains about cost.
- scenarios: derive from agent calls, workflow patterns, or iterations — not a single turn.
- capabilities: derive from agent descriptions, skill calls, and tool sequences.

Output format (valid JSON only, no prose):
{
  "patch": { <partial DesignJSON> },
  "rationale": { "<field.path>": "<which signal(s) justified this>" },
  "skill_proposals": [
    {
      "name": "suggested-skill-name",
      "description": "what this skill would do",
      "trigger": "when to invoke it",
      "workflow": ["tool1", "tool2", "tool3"],
      "source_signals": ["which bundle fields support this proposal"]
    }
  ]
}

skill_proposals: If the session reveals repeatable multi-step workflows (from \
workflow_patterns, agent orchestration, or repeated skill+tool sequences), \
propose them as potential new skills. Only propose when the evidence is strong — \
at least 2 occurrences of a pattern or a clear agent orchestration flow. \
If no strong patterns exist, return an empty list.
"""


def _extract_json(raw: str) -> dict | None:
    start, end = raw.find("{"), raw.rfind("}")
    if start == -1 or end == -1:
        return None
    try:
        return json.loads(raw[start : end + 1])
    except json.JSONDecodeError:
        return None


def _compact_bundle(bundle: Bundle) -> dict:
    """Trim the bundle to fit in a single LLM prompt without losing signal."""
    d = bundle.to_dict()
    if len(d.get("tool_sequence", [])) > 30:
        d["tool_sequence"] = d["tool_sequence"][:15] + [{"tool": "...", "description": f"({len(d['tool_sequence']) - 30} more)"}] + d["tool_sequence"][-15:]
    for agent in d.get("agents", []):
        if len(agent.get("prompt_snippet", "")) > 150:
            agent["prompt_snippet"] = agent["prompt_snippet"][:150] + "..."
    return d


def propose(bundle: Bundle, llm: LLMProvider, max_tokens: int = 1500) -> tuple[dict, dict]:
    """Run the LLM once over the compact bundle. Returns (patch, rationale).

    On any failure (bad JSON, LLM error), returns ({}, {}) — caller falls back
    to starting the interview without a seed.
    """
    body = json.dumps(_compact_bundle(bundle), indent=2)
    try:
        raw = llm.ask(
            history=[
                {"role": "user", "content": f"{PROPOSE_PROMPT}\n\nBundle:\n{body}"},
            ],
            max_tokens=max_tokens,
        )
    except Exception:
        return {}, {}

    parsed = _extract_json(raw)
    if not isinstance(parsed, dict):
        return {}, {}

    patch = parsed.get("patch") or {}
    rationale = parsed.get("rationale") or {}
    if parsed.get("skill_proposals"):
        rationale["_skill_proposals"] = parsed["skill_proposals"]
    return patch, rationale

"""Deterministic transcript ingest — compresses a session transcript into a
small structured bundle before any LLM touches it.

Sources auto-detected:
  - Claude Code session transcript (~/.claude/projects/*/<uuid>.jsonl)
  - skill-studio session (~/.skill-studio/sessions/<uuid>/transcript.md)
  - Arbitrary file via --from-path
  - Current session via CLAUDE_CODE_SESSION_ID env var

Zero LLM calls. Pure regex + parse. The output bundle is meant to fit into
a single LLM prompt for the proposal step.
"""
from __future__ import annotations
import hashlib
import json
import os
import re
from collections import Counter
from dataclasses import dataclass, field, asdict
from pathlib import Path
from typing import Iterable, Literal


Source = Literal["claude-code", "skill-studio", "path"]


MODEL_PATTERNS = [
    r"\b(gpt-[0-9][a-z0-9\-\.]*)\b",
    r"\b(claude-[0-9a-z\-\.]+)\b",
    r"\b(mistral-[a-z0-9\-\.]+)\b",
    r"\b(llama-?\d[a-z0-9\-\.]*)\b",
    r"\b(gemini-[a-z0-9\-\.]+)\b",
    r"\b(sonnet-[0-9a-z\-\.]+)\b",
    r"\b(opus-[0-9a-z\-\.]+)\b",
    r"\b(haiku-[0-9a-z\-\.]+)\b",
]
COST_PATTERNS = [
    re.compile(r"\$(\d+\.\d{2,4})\s*(?:spent|cost|charged|USD)?", re.I),
    re.compile(r"cost[:= ]+\$?(\d+\.\d{2,4})", re.I),
    re.compile(r"usage[:= ]+\$?(\d+\.\d{2,4})", re.I),
]
PROMPT_CHANGE_MARKERS = [
    re.compile(r"\b(retrieval|rag|system)\s+prompt[:= ]", re.I),
    re.compile(r"(changed|updated|tweaked)\s+(the\s+)?prompt", re.I),
    re.compile(r"new prompt", re.I),
]
PAIN_MARKERS = [
    re.compile(r"\b(frustrat|annoy|wast|slow|stuck|blocked|hate|struggle|hurt)\w*", re.I),
    re.compile(r"(too (many|much|long|slow)|keeps? (fail|breaking))", re.I),
]


@dataclass
class AgentCall:
    description: str
    subagent_type: str | None = None
    prompt_snippet: str = ""

    def to_dict(self) -> dict:
        d = {"description": self.description}
        if self.subagent_type:
            d["subagent_type"] = self.subagent_type
        if self.prompt_snippet:
            d["prompt_snippet"] = self.prompt_snippet
        return d


@dataclass
class SkillCall:
    skill: str
    args: str | None = None

    def to_dict(self) -> dict:
        d = {"skill": self.skill}
        if self.args:
            d["args"] = self.args
        return d


@dataclass
class WorkflowStep:
    tool: str
    description: str = ""

    def to_dict(self) -> dict:
        d = {"tool": self.tool}
        if self.description:
            d["description"] = self.description
        return d


@dataclass
class Bundle:
    session_id: str
    source: Source
    models_tried: list[str] = field(default_factory=list)
    prompt_hashes: list[str] = field(default_factory=list)
    iterations: list[dict] = field(default_factory=list)
    pain_snippets: list[str] = field(default_factory=list)
    total_cost_usd: float = 0.0
    turn_count: int = 0
    agents: list[AgentCall] = field(default_factory=list)
    skills: list[SkillCall] = field(default_factory=list)
    tool_sequence: list[WorkflowStep] = field(default_factory=list)
    tool_frequency: dict[str, int] = field(default_factory=dict)
    workflow_patterns: list[dict] = field(default_factory=list)

    def to_dict(self) -> dict:
        d = asdict(self)
        d["agents"] = [a.to_dict() for a in self.agents]
        d["skills"] = [s.to_dict() for s in self.skills]
        d["tool_sequence"] = [w.to_dict() for w in self.tool_sequence]
        d["summary"] = {
            "turns": self.turn_count,
            "iterations": len(self.iterations),
            "models_tried": len(self.models_tried),
            "prompt_variants": len(self.prompt_hashes),
            "total_cost_usd": round(self.total_cost_usd, 4),
            "pain_signals": len(self.pain_snippets),
            "agent_calls": len(self.agents),
            "skill_calls": len(self.skills),
            "unique_tools": len(self.tool_frequency),
            "workflow_patterns": len(self.workflow_patterns),
        }
        return d


def get_current_session_id() -> str | None:
    return os.environ.get("CLAUDE_CODE_SESSION_ID")


def find_claude_code_session(session_id: str, project: str | None = None) -> Path | None:
    root = Path.home() / ".claude" / "projects"
    if not root.exists():
        return None
    if project:
        project_dir = root / project
        if project_dir.exists():
            matches = list(project_dir.glob(f"{session_id}*.jsonl"))
            return matches[0] if matches else None
    matches = list(root.rglob(f"{session_id}*.jsonl"))
    return matches[0] if matches else None


def list_claude_code_sessions(project: str | None = None, limit: int = 20) -> list[dict]:
    root = Path.home() / ".claude" / "projects"
    if not root.exists():
        return []
    if project:
        dirs = [root / project]
    else:
        dirs = [d for d in root.iterdir() if d.is_dir()]
    results = []
    for d in dirs:
        for f in d.glob("*.jsonl"):
            sid = f.stem
            title = _read_session_title(f)
            results.append({
                "session_id": sid,
                "project": d.name,
                "modified": f.stat().st_mtime,
                "size_kb": round(f.stat().st_size / 1024, 1),
                "title": title,
            })
    results.sort(key=lambda r: r["modified"], reverse=True)
    return results[:limit]


def _read_session_title(path: Path) -> str:
    for line in path.open():
        try:
            obj = json.loads(line)
            if obj.get("type") == "ai-title":
                return obj.get("title", "")
        except json.JSONDecodeError:
            continue
    return ""


def find_skill_studio_session(session_id: str) -> Path | None:
    from skill_studio import paths
    for d in paths.session_root().glob(f"{session_id}*"):
        t = d / "transcript.md"
        if t.exists():
            return t
    return None


def resolve_session(session_id: str, *, project: str | None = None) -> tuple[Path, Source]:
    """Find a session by id across known sources. Raises if not found."""
    p = find_claude_code_session(session_id, project=project)
    if p is not None:
        return p, "claude-code"
    p = find_skill_studio_session(session_id)
    if p is not None:
        return p, "skill-studio"
    raise FileNotFoundError(f"session not found: {session_id}")


def resolve_current_session(*, project: str | None = None) -> tuple[Path, str]:
    """Find the current running session via env var. Returns (path, session_id)."""
    sid = get_current_session_id()
    if not sid:
        raise RuntimeError(
            "CLAUDE_CODE_SESSION_ID not set — run inside a Claude Code session "
            "or pass a session_id explicitly"
        )
    p = find_claude_code_session(sid, project=project)
    if p is None:
        raise FileNotFoundError(f"current session file not found: {sid}")
    return p, sid


def _iter_text(path: Path) -> Iterable[str]:
    if path.suffix == ".jsonl":
        for line in path.read_text().splitlines():
            try:
                obj = json.loads(line)
                msg = obj.get("message") or obj
                content = msg.get("content") if isinstance(msg, dict) else None
                if isinstance(content, list):
                    for block in content:
                        if isinstance(block, dict) and block.get("type") == "text":
                            yield block.get("text", "")
                elif isinstance(content, str):
                    yield content
            except json.JSONDecodeError:
                continue
    else:
        yield path.read_text()


def _iter_tool_uses(path: Path) -> Iterable[dict]:
    """Yield tool_use blocks from assistant messages in a JSONL session."""
    if path.suffix != ".jsonl":
        return
    for line in path.read_text().splitlines():
        try:
            obj = json.loads(line)
        except json.JSONDecodeError:
            continue
        if obj.get("type") != "assistant":
            continue
        msg = obj.get("message", {})
        content = msg.get("content", [])
        if not isinstance(content, list):
            continue
        for block in content:
            if isinstance(block, dict) and block.get("type") == "tool_use":
                yield block


def _detect_workflow_patterns(steps: list[WorkflowStep], min_length: int = 2, min_count: int = 2) -> list[dict]:
    """Find repeated subsequences of tool calls that indicate a workflow.
    Filters out homogeneous sequences (e.g. Bash→Bash) since those are noise.
    """
    if len(steps) < min_length * min_count:
        return []
    tool_names = [s.tool for s in steps]
    patterns: Counter[tuple[str, ...]] = Counter()
    for length in range(min_length, min(6, len(tool_names) // min_count + 1)):
        for i in range(len(tool_names) - length + 1):
            seq = tuple(tool_names[i : i + length])
            if len(set(seq)) < 2:
                continue
            patterns[seq] += 1
    results = []
    seen_supersets: set[tuple[str, ...]] = set()
    for seq, count in patterns.most_common():
        if count < min_count:
            continue
        is_subset = any(
            len(sup) > len(seq) and _is_subsequence(seq, sup)
            for sup in seen_supersets
        )
        if is_subset:
            continue
        seen_supersets.add(seq)
        results.append({
            "tools": list(seq),
            "count": count,
            "label": " → ".join(seq),
        })
    return results[:10]


def _is_subsequence(short: tuple[str, ...], long: tuple[str, ...]) -> bool:
    it = iter(long)
    return all(c in it for c in short)


def extract(path: Path, session_id: str, source: Source, *, max_pain_snippets: int = 6) -> Bundle:
    b = Bundle(session_id=session_id, source=source)
    seen_models: set[str] = set()
    seen_prompts: set[str] = set()
    tool_counter: Counter[str] = Counter()

    for block in _iter_tool_uses(path):
        name = block.get("name", "")
        inp = block.get("input", {})
        tool_counter[name] += 1

        if name == "Agent":
            desc = inp.get("description", "")
            prompt = inp.get("prompt", "")
            agent = AgentCall(
                description=desc,
                subagent_type=inp.get("subagent_type"),
                prompt_snippet=prompt[:200] if prompt else "",
            )
            b.agents.append(agent)
            b.tool_sequence.append(WorkflowStep(tool="Agent", description=desc))
        elif name == "Skill":
            skill = SkillCall(skill=inp.get("skill", ""), args=inp.get("args"))
            b.skills.append(skill)
            b.tool_sequence.append(WorkflowStep(tool="Skill", description=inp.get("skill", "")))
        else:
            desc = inp.get("description", "")
            b.tool_sequence.append(WorkflowStep(tool=name, description=desc))

    b.tool_frequency = dict(tool_counter.most_common())
    b.workflow_patterns = _detect_workflow_patterns(b.tool_sequence)

    for chunk in _iter_text(path):
        b.turn_count += 1

        for pattern in MODEL_PATTERNS:
            for m in re.findall(pattern, chunk, re.I):
                seen_models.add(m.lower())

        cost_spans: dict[tuple[int, int], float] = {}
        for rx in COST_PATTERNS:
            for m in rx.finditer(chunk):
                try:
                    amt = float(m.group(1))
                except (ValueError, IndexError):
                    continue
                if 0.001 <= amt <= 100:
                    span = m.span(1)
                    cost_spans.setdefault(span, amt)
        for amt in cost_spans.values():
            b.total_cost_usd += amt
            b.iterations.append({"action": "cost_event", "amount_usd": amt})

        for rx in PROMPT_CHANGE_MARKERS:
            if rx.search(chunk):
                h = hashlib.sha1(chunk.encode("utf-8", "ignore")).hexdigest()[:8]
                if h not in seen_prompts:
                    seen_prompts.add(h)
                    b.iterations.append({"action": "prompt_change", "hash": h})
                break

        if len(b.pain_snippets) < max_pain_snippets:
            for rx in PAIN_MARKERS:
                m = rx.search(chunk)
                if m:
                    start = max(0, m.start() - 60)
                    end = min(len(chunk), m.end() + 60)
                    snippet = chunk[start:end].strip().replace("\n", " ")
                    if snippet and snippet not in b.pain_snippets:
                        b.pain_snippets.append(snippet)
                        break

    b.models_tried = sorted(seen_models)
    b.prompt_hashes = sorted(seen_prompts)
    return b

"""Interactive first-run wizard. Walks a new user through prereq checks,
data-home selection, encryption mode, LLM/voice provider setup, and prints
a shell-rc snippet with the env vars they need exported.

Wraps the narrower `setup.run_setup` (which only handles key entry via sops).
The wizard falls back to plaintext dotenv when sops is unavailable."""
from __future__ import annotations
import getpass
import os
import shutil
import subprocess
import sys
from pathlib import Path
from typing import Callable

from skill_studio import paths


# ---------------------------------------------------------------------------
# Prereqs
# ---------------------------------------------------------------------------

def check_python() -> tuple[bool, str]:
    major, minor = sys.version_info[:2]
    ok = (major, minor) >= (3, 11)
    return ok, f"Python {major}.{minor} ({'ok' if ok else 'need 3.11+'})"


def check_sops() -> tuple[bool, str]:
    path = shutil.which("sops")
    if not path:
        return False, "sops: not found on PATH"
    return True, f"sops: {path}"


def check_age_key() -> tuple[bool, str]:
    """age key is needed for sops. Accept either SOPS_AGE_KEY_FILE or the
    standard ~/.config/sops/age/keys.txt location."""
    env = os.environ.get("SOPS_AGE_KEY_FILE")
    if env and Path(env).expanduser().exists():
        return True, f"age key: {env}"
    default = Path.home() / ".config/sops/age/keys.txt"
    if default.exists():
        return True, f"age key: {default}"
    return False, "age key: not found (SOPS_AGE_KEY_FILE unset; ~/.config/sops/age/keys.txt missing)"


# ---------------------------------------------------------------------------
# Prompts
# ---------------------------------------------------------------------------

def _prompt(label: str, default: str = "") -> str:
    suffix = f" [{default}]" if default else ""
    ans = input(f"{label}{suffix}: ").strip()
    return ans or default


def _prompt_yn(label: str, default: bool = True) -> bool:
    marker = "Y/n" if default else "y/N"
    ans = input(f"{label} [{marker}]: ").strip().lower()
    if not ans:
        return default
    return ans.startswith("y")


def _prompt_choice(label: str, choices: list[str], default: str) -> str:
    shown = "/".join(c if c != default else c.upper() for c in choices)
    while True:
        ans = input(f"{label} ({shown}): ").strip().lower() or default
        if ans in choices:
            return ans
        print(f"  pick one of: {', '.join(choices)}")


# ---------------------------------------------------------------------------
# Env writing
# ---------------------------------------------------------------------------

def _write_plaintext_env(path: Path, entries: dict[str, str]) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    body = "\n".join(f"{k}={v}" for k, v in entries.items()) + "\n"
    path.write_text(body)
    path.chmod(0o600)


def _write_sops_env(path: Path, entries: dict[str, str]) -> None:
    from skill_studio.sops_helper import encrypt_dotenv
    _write_plaintext_env(path, entries)
    encrypt_dotenv(path)


# ---------------------------------------------------------------------------
# Smoke test
# ---------------------------------------------------------------------------

def _smoke_test() -> bool:
    """Run `pytest -q` inside the project. Returns True on pass."""
    root = Path(__file__).resolve().parents[2]
    try:
        r = subprocess.run(
            [sys.executable, "-m", "pytest", "-q", "--no-header", "-x"],
            cwd=root,
            capture_output=True,
            text=True,
            timeout=120,
        )
    except Exception as e:
        print(f"  smoke test could not run: {e}")
        return False
    if r.returncode == 0:
        last = r.stdout.strip().splitlines()[-1] if r.stdout else ""
        print(f"  ✓ {last}")
        return True
    print(r.stdout[-500:])
    print(r.stderr[-500:])
    return False


# ---------------------------------------------------------------------------
# Main flow
# ---------------------------------------------------------------------------

BANNER = """
╭─────────────────────────────────────────────╮
│  skill-studio — first-run setup wizard      │
╰─────────────────────────────────────────────╯
"""


def run_init_wizard(
    input_fn: Callable[[str], str] | None = None,
) -> int:
    """Return 0 on success, non-zero on abort."""
    # input_fn injection is for tests; default module uses builtin input.
    if input_fn is not None:
        global input
        input = input_fn  # type: ignore[assignment]

    print(BANNER)

    # 1. Prereqs
    print("Checking prerequisites…")
    py_ok, py_msg = check_python()
    sops_ok, sops_msg = check_sops()
    age_ok, age_msg = check_age_key()
    for ok, msg in [(py_ok, py_msg), (sops_ok, sops_msg), (age_ok, age_msg)]:
        print(f"  {'✓' if ok else '·'} {msg}")

    if not py_ok:
        print("\nPython 3.11+ is required. Aborting.")
        return 1

    # 2. Data home
    print("\n— Data location —")
    current_home = os.environ.get("SKILL_STUDIO_HOME") or str(paths.home())
    data_home = Path(_prompt("Data home (sessions + cache)", current_home)).expanduser()
    data_home.mkdir(parents=True, exist_ok=True)
    (data_home / "sessions").mkdir(exist_ok=True)
    print(f"  ✓ {data_home}")

    # 3. Encryption mode
    print("\n— Secrets storage —")
    sops_available = sops_ok and age_ok
    if sops_available:
        encrypt = _prompt_yn("Encrypt provider keys with sops?", default=True)
    else:
        print("  sops unavailable — secrets will be stored in plaintext (chmod 600).")
        print("  Install sops + age to enable encryption later: https://github.com/getsops/sops")
        encrypt = False
    env_file = Path(_prompt(
        "Env file path",
        os.environ.get("SKILL_STUDIO_ENV_FILE") or str(paths.env_file()),
    )).expanduser()

    # 4. LLM provider
    print("\n— LLM provider —")
    provider = _prompt_choice(
        "Provider",
        ["openrouter", "anthropic", "skip"],
        default="openrouter",
    )
    entries: dict[str, str] = {}
    if provider == "openrouter":
        key = getpass.getpass("  OPENROUTER_API_KEY (hidden, Enter to skip): ").strip()
        if key:
            entries["OPENROUTER_API_KEY"] = key
            entries["LLM_PROVIDER"] = "openrouter"
            entries["OPENROUTER_MODEL"] = _prompt(
                "  OpenRouter model", "anthropic/claude-opus-4"
            )
    elif provider == "anthropic":
        key = getpass.getpass("  ANTHROPIC_API_KEY (hidden, Enter to skip): ").strip()
        if key:
            entries["ANTHROPIC_API_KEY"] = key
            entries["LLM_PROVIDER"] = "anthropic"
    else:
        print("  Skipped — text mode inside Claude Code still works without a provider key.")

    # 5. Voice mode
    print("\n— Voice mode —")
    want_voice = _prompt_yn("Enable voice mode? (needs Daily / Groq / Deepgram)", default=False)
    if want_voice:
        for k, label in [
            ("DAILY_API_KEY", "Daily API key"),
            ("GROQ_API_KEY", "Groq API key"),
            ("DEEPGRAM_API_KEY", "Deepgram API key"),
        ]:
            v = getpass.getpass(f"  {label} (hidden): ").strip()
            if v:
                entries[k] = v
        entries.setdefault("DEEPGRAM_VOICE", "aura-asteria-en")

    # 6. Write env file
    if entries:
        print(f"\nWriting env file to {env_file} ({'sops-encrypted' if encrypt else 'plaintext'})…")
        try:
            if encrypt:
                _write_sops_env(env_file, entries)
            else:
                _write_plaintext_env(env_file, entries)
            print("  ✓")
        except Exception as e:
            print(f"  ✗ {e}")
            return 2
    else:
        print("\nNo keys captured — skipping env file write.")

    # 7. Shell rc snippet
    print("\n— Shell configuration —")
    lines = [
        f'export SKILL_STUDIO_HOME="{data_home}"',
        f'export SKILL_STUDIO_ENV_FILE="{env_file}"',
    ]
    print("Add these to your shell rc (~/.zshrc, ~/.bashrc, etc.):\n")
    for line in lines:
        print(f"  {line}")

    # 8. Smoke test
    print("\n— Smoke test —")
    if _prompt_yn("Run test suite to verify install?", default=True):
        ok = _smoke_test()
        if not ok:
            print("  tests failed — check output above")

    print("\nDone. Try: skill-studio new --preset ai-agent --depth sprint")
    return 0

"""Finding 2: Fold extractor + director landing check into a single LLM call.

Each user turn previously made 2 sequential LLM calls:
  1. extract_and_apply  — extract schema fields from transcript tail
  2. _subject_landed    — decide if current subject has been addressed

This module collapses them into one call that returns both signals at once,
cutting per-turn LLM latency in half in voice mode.
"""
from __future__ import annotations
import json
from skill_studio.schema import DesignJSON
from skill_studio.interview.subjects import Subject
from skill_studio.interview.merge import deep_merge


COMBINED_PROMPT = """\
You are an AI interview assistant. Given recent interview exchanges and the \
current landing criterion, perform two tasks at once and return a single JSON \
object with exactly two keys:

1. "landed": true if the user's latest answer satisfies the landing criterion, \
false otherwise.
2. "patch": a partial DesignJSON object containing only fields the transcript \
actually fills — or an empty object {} if nothing concrete was said.

Respond with ONLY valid JSON. No commentary. No markdown fences. Example:
{"landed": true, "patch": {"hook": "Weekly review drafter"}}
"""


def analyze_turn(
    design: DesignJSON,
    subject: Subject | None,
    transcript_tail: list[dict],
    llm,
) -> tuple[bool, dict]:
    """Single LLM call: decide if subject landed AND extract schema patch.

    Returns (landed: bool, patch: dict).
    Falls back to (False, {}) on any parse or network error.
    """
    landing_criterion = subject.landing_criterion if subject else "always true"
    context = "\n".join(f"{t['role']}: {t['text']}" for t in transcript_tail[-6:])
    user_msg = (
        f"{COMBINED_PROMPT}\n\n"
        f"Landing criterion: {landing_criterion}\n\n"
        f"Recent exchanges:\n{context}\n\n"
        f"JSON:"
    )
    try:
        raw = llm.ask(history=[{"role": "user", "content": user_msg}], max_tokens=900)
    except Exception:
        return False, {}

    start, end = raw.find("{"), raw.rfind("}")
    if start == -1 or end == -1:
        return False, {}
    try:
        result = json.loads(raw[start:end + 1])
    except json.JSONDecodeError:
        return False, {}

    landed = bool(result.get("landed", False))
    patch = result.get("patch", {})
    if not isinstance(patch, dict):
        patch = {}

    if patch:
        deep_merge(design, patch)

    return landed, patch

from __future__ import annotations
from typing import Any
from skill_studio.schema import DesignJSON
from skill_studio.presets import Preset


def _get(obj: Any, path: str) -> Any:
    """Walk dotted path on a pydantic model or dict."""
    cur: Any = obj
    for part in path.split("."):
        if hasattr(cur, part):
            cur = getattr(cur, part)
        elif isinstance(cur, dict):
            cur = cur.get(part)
        else:
            return None
    return cur


def _flatten_weights(weights: dict[str, Any], prefix: str = "") -> dict[str, float]:
    out: dict[str, float] = {}
    for k, v in weights.items():
        full = f"{prefix}.{k}" if prefix else k
        if isinstance(v, dict):
            out.update(_flatten_weights(v, full))
        else:
            out[full] = float(v)
    return out


def score_coverage(design: DesignJSON) -> dict[str, float]:
    """Return per-field confidence 0..1. Simple v1 heuristic."""
    scores: dict[str, float] = {}
    checkable = [
        "hook", "problem.what_hurts", "problem.cost_today",
        "jtbd.situation", "jtbd.motivation", "jtbd.outcome",
        "before_after.before_external", "before_after.before_internal",
        "before_after.after_external",  "before_after.after_internal",
        "cta",
        "trigger.detail",
    ]
    for path in checkable:
        val = _get(design, path)
        scores[path] = 1.0 if (isinstance(val, str) and val.strip()) else 0.0
    list_targets = {
        "needs.functional": 2, "needs.emotional": 1, "needs.social": 1,
        "inputs": 2, "capabilities": 2, "outputs": 1, "guardrails": 1,
        "scenarios": 1,
    }
    for path, target in list_targets.items():
        val = _get(design, path) or []
        scores[path] = min(1.0, len(val) / target)
    scores["concept_imagery.metaphor"] = 1.0 if (design.concept_imagery.metaphor or "").strip() else 0.0

    # Aggregate top-level scores so presets that weight a whole submodel (e.g.
    # `before_after: 0.7`) get credited once its nested fields are filled.
    def _group_mean(prefix: str) -> float:
        sub = [v for k, v in scores.items() if k.startswith(f"{prefix}.")]
        return sum(sub) / len(sub) if sub else 0.0

    for group in ("before_after", "problem", "jtbd", "trigger", "concept_imagery"):
        scores.setdefault(group, _group_mean(group))
    return scores


def overall_coverage(design: DesignJSON, preset: Preset) -> float:
    scores = score_coverage(design)
    weights = _flatten_weights(preset.field_weights)
    total_weight = sum(weights.values())
    if total_weight == 0:
        return 0.0
    weighted = sum(scores.get(k, 0.0) * w for k, w in weights.items())
    return weighted / total_weight


def next_uncovered_field(design: DesignJSON, preset: Preset) -> str | None:
    scores = score_coverage(design)
    weights = _flatten_weights(preset.field_weights)
    candidates = [(k, w * (1.0 - scores.get(k, 0.0))) for k, w in weights.items()]
    candidates.sort(key=lambda kv: kv[1], reverse=True)
    for k, gain in candidates:
        if gain > 0.01:
            return k
    return None

from __future__ import annotations
from dataclasses import dataclass, field
from enum import Enum
from skill_studio.interview.phases import Phase, next_phase, ARC
from skill_studio.interview.subjects import subjects_for, Subject, SUBJECTS


class MoveKind(str, Enum):
    FOLLOW_UP = "follow_up"
    NEW_SUBJECT = "new_subject"
    ADVANCE_PHASE = "advance_phase"
    CLOSE = "close"


@dataclass
class DirectorState:
    phase: Phase = Phase.OPENING
    current_subject: Subject | None = None
    subjects_landed: set[str] = field(default_factory=set)
    follow_ups_on_current: int = 0
    max_follow_ups: int = 4  # conversational default; each subject gets more probing before moving on
    asked_questions_per_phase: dict[str, list[str]] = field(default_factory=dict)

    def to_schema_state(self):
        """Serialize to InterviewState for persistence in DesignJSON."""
        from skill_studio.schema import InterviewState
        return InterviewState(
            phase=self.phase.value,
            current_subject_key=self.current_subject.key if self.current_subject else None,
            subjects_landed=list(self.subjects_landed),
            follow_ups_on_current=self.follow_ups_on_current,
            max_follow_ups=self.max_follow_ups,
            asked_questions_per_phase={
                k: list(v) for k, v in self.asked_questions_per_phase.items()
            },
        )

    @classmethod
    def from_schema_state(cls, state) -> "DirectorState":
        """Hydrate from a persisted InterviewState schema object."""
        phase = Phase(state.phase)
        # Resolve current subject from key
        current_subject: Subject | None = None
        if state.current_subject_key:
            for subj_list in SUBJECTS.values():
                for s in subj_list:
                    if s.key == state.current_subject_key:
                        current_subject = s
                        break
        return cls(
            phase=phase,
            current_subject=current_subject,
            subjects_landed=set(state.subjects_landed),
            follow_ups_on_current=state.follow_ups_on_current,
            max_follow_ups=state.max_follow_ups,
            asked_questions_per_phase={
                k: list(v) for k, v in state.asked_questions_per_phase.items()
            },
        )


@dataclass
class Move:
    kind: MoveKind
    phase: Phase
    subject: Subject | None
    rationale: str = ""


def next_move(state: DirectorState, last_user_text: str | None = None, llm=None, *, landed: bool | None = None) -> Move:
    """Decide the next move.

    Two call modes:
      - Legacy: next_move(state, last_user_text, llm) — calls _subject_landed internally (2 LLM calls per turn).
      - Fast:   next_move(state, landed=<bool>)        — caller passes pre-computed landed signal
                (used by combined.analyze_turn for 1 LLM call per turn).
    """
    # Initial move: first subject of current phase
    if state.current_subject is None:
        subjects = subjects_for(state.phase)
        if not subjects:
            nxt = next_phase(state.phase)
            return Move(
                MoveKind.ADVANCE_PHASE if nxt else MoveKind.CLOSE,
                nxt or Phase.CLOSE,
                None,
                "no subjects in phase",
            )
        return Move(MoveKind.NEW_SUBJECT, state.phase, subjects[0], "first subject in phase")

    # Resolve landed signal
    if landed is None:
        # Legacy path: call LLM directly
        landed = _subject_landed(state.current_subject, last_user_text or "", llm)

    if not landed and state.follow_ups_on_current < state.max_follow_ups:
        return Move(MoveKind.FOLLOW_UP, state.phase, state.current_subject, "not landed, follow up")

    # Mark landed (or give up after max follow-ups) and find next subject in phase
    remaining = [
        s for s in subjects_for(state.phase)
        if s.key not in state.subjects_landed and s.key != state.current_subject.key
    ]
    if remaining:
        return Move(MoveKind.NEW_SUBJECT, state.phase, remaining[0], "next subject in phase")

    # Phase done — advance
    nxt = next_phase(state.phase)
    if nxt is None:
        return Move(MoveKind.CLOSE, Phase.CLOSE, None, "arc complete")
    return Move(MoveKind.ADVANCE_PHASE, nxt, None, f"advance {state.phase.value} -> {nxt.value}")


def _subject_landed(subject: Subject, last_user_text: str, llm) -> bool:
    """Ask the LLM whether the user's last answer satisfies the landing criterion.

    Legacy helper — kept for callers that use the 2-LLM-call path.
    The hot path now goes through combined.analyze_turn for 1 call per turn.
    """
    if not last_user_text or len(last_user_text.strip()) < 5:
        return False
    prompt = (
        f"Landing criterion: {subject.landing_criterion}\n"
        f"User just said: {last_user_text!r}\n\n"
        f"Does this answer satisfy the landing criterion? Reply with only 'YES' or 'NO'."
    )
    try:
        resp = llm.ask(history=[{"role": "user", "content": prompt}], max_tokens=5)
        return resp.strip().upper().startswith("YES")
    except Exception:
        return False  # conservative