product-playbook 1.1.1 → 1.2.0

package/.claude-plugin/marketplace.json

@@ -7,7 +7,7 @@
     {
       "name": "product-playbook",
       "description": "MUST use when user wants to plan or strategize a product/feature. 22 PM frameworks, 6 modes, multi-language, from idea to dev handoff",
-      "version": "1.1.1",
+      "version": "1.2.0",
       "source": "./."
     }
   ]

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "product-playbook",
   "description": "MUST use when user wants to plan or strategize a product/feature. 22 PM frameworks, 6 modes, multi-language, from idea to dev handoff",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "author": {
     "name": "Charles Chen"
   },

package/README.es.md

@@ -280,6 +280,18 @@ Genera un paquete completo de handoff de desarrollo e inicia desarrollo en Claud
 > Por favor lee CLAUDE.md y TASKS.md, comienza ejecutando la Fase 0
 ```
 
+### 🪝 Hooks de Ciclo de Vida
+
+Tres hooks del plugin convierten las reglas centrales del playbook de "Claude debe recordarlas" a "el harness las aplica de forma determinista". Todos los hooks inyectan recordatorios suaves vía `systemMessage` — **ninguno bloquea al usuario**.
+
+| Evento | Disparador | Acción |
+|--------|-----------|--------|
+| `SessionStart` | Cada sesión nueva o reanudada | Inyecta automáticamente `.product-playbook-progress.md` y `.product-context.md` en el contexto del modelo, para que una sesión de planificación interrumpida se reanude exactamente desde el paso pausado |
+| `UserPromptSubmit` | Cada prompt durante una sesión de planificación activa | Detecta (a) prompts off-topic (debug / error / "arregla este código") y recuerda a Claude aplicar la regla de guardar progreso de SKILL.md; (b) palabras clave de intención de cambio (`改 step 2`, `update persona`, `rehacer JTBD`) y recuerda aplicar las reglas de Change Propagation |
+| `PreToolUse` (Write/Edit/MultiEdit) | Antes de cada escritura de archivo | Si el proyecto sigue en fase de planificación (sin marcador `.product-dev-active`) y el destino es código fuente (`.ts/.tsx/.py/.go/...`), recuerda a Claude que la planificación produce documentos, no código. El marcador se crea automáticamente al ejecutar `/product-dev` |
+
+Los hooks se cargan automáticamente desde `hooks/hooks.json` al instalar el plugin. Operan como no-op fuera de proyectos product-playbook, por lo que instalar el plugin no afecta a otros codebases.
+
 ### 📄 Importación y Exportación de Documentos
 
 **Importa** cualquier documento existente al flujo de planificación — sin copiar y pegar manualmente:

package/README.ja.md

@@ -281,6 +281,18 @@ MVPを修正 → User Stories、DBスキーマ、プロダクトスペックサ
 > CLAUDE.mdとTASKS.mdを読んで、Phase 0の実行を開始してください
 ```
 
+### 🪝 ライフサイクルフック
+
+3つのプラグインフックで、Playbook の中核ルールを「Claude の記憶頼み」から「ハーネスによる強制実行」へ昇格させます。すべてのフックは `systemMessage` によるソフトリマインダーを注入するのみで、**ユーザーを止めることはありません**。
+
+| イベント | トリガー | 役割 |
+|---------|---------|------|
+| `SessionStart` | 新規 / 再開セッションごと | `.product-playbook-progress.md` と `.product-context.md` を自動でモデルの context に注入し、中断した企画を直前のステップから途切れなく再開 |
+| `UserPromptSubmit` | 企画進行中のプロンプト送信ごと | (a) 脱線メッセージ（debug / エラー / "このコード直して"）を検出して SKILL.md の進捗保存ルールを実行するよう Claude に指示。(b) 変更意図キーワード（`改 step 2`、`update persona`、`JTBD やり直し`）を検出して Change Propagation ルールの適用を促す |
+| `PreToolUse` (Write/Edit/MultiEdit) | ファイル書き込み前 | プロジェクトが企画フェーズ（`.product-dev-active` マーカー無し）で、対象がソースコード拡張子（`.ts/.tsx/.py/.go/...`）の場合、「企画はドキュメントのみ、コードは生成しない」と Claude にリマインド。マーカーは `/product-dev` 実行時に自動生成 |
+
+フックはプラグインインストール時に `hooks/hooks.json` から自動ロードされます。product-playbook プロジェクト外では完全に no-op で動作するため、他のコードベースへの影響はありません。
+
 ### 📄 ドキュメントインポート＆エクスポート
 
 **インポート** — 既存のドキュメントを企画フローに直接取り込み、手動コピペ不要：

package/README.ko.md

@@ -280,6 +280,18 @@ MVP 수정  → User Stories, DB Schema, 제품 스펙 요약 자동 업데이
 > CLAUDE.md와 TASKS.md를 읽고, Phase 0 실행 시작
 ```
 
+### 🪝 라이프사이클 훅
+
+세 개의 플러그인 훅이 Playbook의 핵심 규칙을 "Claude가 알아서 기억"에서 "하네스가 강제 실행"으로 끌어올립니다. 모든 훅은 `systemMessage` 형태의 소프트 리마인더만 주입하며, **사용자를 막지 않습니다**.
+
+| 이벤트 | 트리거 시점 | 역할 |
+|--------|------------|------|
+| `SessionStart` | 새 세션 또는 재개 시마다 | `.product-playbook-progress.md`와 `.product-context.md`를 자동으로 모델 context에 주입하여, 중단된 기획을 직전 단계에서 매끄럽게 이어가도록 함 |
+| `UserPromptSubmit` | 기획 진행 중 프롬프트 제출마다 | (a) 주제 이탈 메시지(debug / 에러 / "이 코드 고쳐주세요")를 감지해 SKILL.md의 진행 상황 저장 규칙을 따르도록 Claude에 지시. (b) 변경 의도 키워드(`改 step 2`, `update persona`, `JTBD 다시 작성`)를 감지해 Change Propagation 규칙 적용을 환기 |
+| `PreToolUse` (Write/Edit/MultiEdit) | 파일 쓰기 전마다 | 프로젝트가 기획 단계(`.product-dev-active` 마커 없음)이고 대상이 소스 코드 확장자(`.ts/.tsx/.py/.go/...`)일 경우, "기획은 문서만 생성, 코드는 생성하지 않는다"는 원칙을 Claude에 리마인드. 마커는 `/product-dev` 실행 시 자동 생성됨 |
+
+훅은 플러그인 설치 시 `hooks/hooks.json`에서 자동 로드됩니다. product-playbook 프로젝트가 아닌 곳에서는 완전히 no-op이므로 다른 codebase에 영향을 주지 않습니다.
+
 ### 📄 문서 가져오기 및 내보내기
 
 **가져오기** — 기존 문서를 기획 플로우에 직접 투입, 수동 복사 붙여넣기 불필요:

package/README.md

@@ -280,6 +280,18 @@ Generate a complete dev handoff package and kick off Claude Code development wit
 > Please read CLAUDE.md and TASKS.md, start executing Phase 0
 ```
 
+### 🪝 Lifecycle Hooks
+
+Three plugin hooks turn the playbook's core rules from "Claude needs to remember" into harness-enforced behavior. All hooks emit advisory `systemMessage` reminders — none of them block the user.
+
+| Event | Trigger | What it does |
+|-------|---------|--------------|
+| `SessionStart` | Every new / resumed session | Auto-injects `.product-playbook-progress.md` and `.product-context.md` into the model's context so a planning session resumes from the exact step it was paused at. |
+| `UserPromptSubmit` | Each user prompt during an active planning session | Detects (a) off-topic prompts (debug / error / "fix this code") and reminds Claude to follow the off-topic save-progress rule, and (b) change-intent keywords (`改 step 2`, `update persona`, `重做 JTBD`) and reminds Claude to apply the Change Propagation rules. |
+| `PreToolUse` (Write/Edit/MultiEdit) | Each file-write attempt | If the project is still in planning mode (no `.product-dev-active` marker) and the target is a source-code file (`.ts/.tsx/.py/.go/...`), reminds Claude that planning produces docs, not code. The marker is auto-created when `/product-dev` runs. |
+
+Hooks are auto-loaded from `hooks/hooks.json` when the plugin is installed. They no-op outside playbook projects, so installing the plugin has zero effect on unrelated codebases.
+
 ### 📄 Document Import & Export
 
 **Import** any existing document into the planning flow — no manual copy-paste:

package/README.zh-CN.md

@@ -280,6 +280,18 @@ product-playbook/
 > 请读取 CLAUDE.md 和 TASKS.md，开始执行 Phase 0
 ```
 
+### 🪝 生命周期 Hooks
+
+三个 plugin hook 将 playbook 的核心规则从「靠 Claude 自己记得」转为「由 harness 强制执行」。所有 hook 只注入 `systemMessage` 软提醒，**不阻挡用户**。
+
+| 事件 | 触发时机 | 作用 |
+|------|---------|------|
+| `SessionStart` | 每次新 session 或 resume | 自动将 `.product-playbook-progress.md` 与 `.product-context.md` 注入模型 context，让中断的规划从原步骤无缝接续 |
+| `UserPromptSubmit` | 规划进行中每次提交 prompt | 检测（a）离题消息（debug / 错误 / "帮我改 code"）→ 提醒 Claude 执行 SKILL.md 的存档规则；（b）变更意图关键字（`改 step 2`、`update persona`、`重做 JTBD`）→ 提醒套用 Change Propagation 规则 |
+| `PreToolUse` (Write/Edit/MultiEdit) | 每次写文件前 | 若项目仍在规划阶段（无 `.product-dev-active` 标记）且目标是源代码后缀（`.ts/.tsx/.py/.go/...`），提醒 Claude「规划只产文档、不产 code」。`/product-dev` 执行时会自动建立该标记 |
+
+Hooks 由 `hooks/hooks.json` 在 plugin 安装时自动加载。在非 product-playbook 项目中完全 no-op，安装 plugin 不会影响其他 codebase。
+
 ### 📄 文档导入与导出
 
 **导入**任何现有文档到规划流程中 — 无需手动复制粘贴：

package/README.zh-TW.md

@@ -280,6 +280,18 @@ product-playbook/
 > 請讀取 CLAUDE.md 和 TASKS.md，開始執行 Phase 0
 ```
 
+### 🪝 生命週期 Hooks
+
+三個 plugin hook 將 playbook 的核心規則從「靠 Claude 自己記得」轉為「由 harness 強制執行」。所有 hook 只注入 `systemMessage` 軟提醒，**不阻擋使用者**。
+
+| 事件 | 觸發時機 | 作用 |
+|------|---------|------|
+| `SessionStart` | 每次新 session 或 resume | 自動將 `.product-playbook-progress.md` 與 `.product-context.md` 注入模型 context，讓中斷的規劃從原步驟無縫接續 |
+| `UserPromptSubmit` | 規劃進行中每次送出 prompt | 偵測（a）離題訊息（debug / 錯誤 / "幫我改 code"）→ 提醒 Claude 執行 SKILL.md 的存檔規則；（b）變更意圖關鍵字（`改 step 2`、`update persona`、`重做 JTBD`）→ 提醒套用 Change Propagation 規則 |
+| `PreToolUse` (Write/Edit/MultiEdit) | 每次寫檔前 | 若專案仍在規劃階段（無 `.product-dev-active` 標記）且目標是原始碼副檔名（`.ts/.tsx/.py/.go/...`），提醒 Claude「規劃只產文件、不產 code」。`/product-dev` 執行時會自動建立該標記 |
+
+Hooks 由 `hooks/hooks.json` 在 plugin 安裝時自動載入。在非 product-playbook 專案中完全 no-op，安裝 plugin 不會影響其他 codebase。
+
 ### 📄 文件匯入與匯出
 
 **匯入**任何現有文件到規劃流程中 — 無需手動複製貼上：

package/commands/product-dev.md

@@ -10,12 +10,15 @@ Then read the following reference files in order:
 
 Based on the product planning content completed in the current conversation, generate the full dev handoff package:
 1. Confirm the tech stack (if not specified by the user, recommend one based on product characteristics)
-2. Generate CLAUDE.md (Claude Code project memory)
-3. Generate TASKS.md (feature breakdown + phased releases + acceptance criteria)
-4. Generate TICKETS.md (ticket list)
-5. Generate docs/ARCHITECTURE.md (directory structure + DB Schema + API Endpoints)
-6. Generate docs/PRD.md + docs/PRODUCT-SPEC.md
-7. Generate scripts/setup.sh (one-click initialization)
-8. Display Claude Code transition guide
+2. Create the `.product-dev-active` marker file at the project root (empty file). This signals the plugin's PreToolUse hook that the project has officially entered the dev-handoff phase, so subsequent source-code writes are no longer gated.
+3. Generate CLAUDE.md (Claude Code project memory)
+4. Generate TASKS.md (feature breakdown + phased releases + acceptance criteria)
+5. Generate TICKETS.md (ticket list)
+6. Generate docs/ARCHITECTURE.md (directory structure + DB Schema + API Endpoints)
+7. Generate docs/PRD.md + docs/PRODUCT-SPEC.md
+8. Generate scripts/setup.sh (one-click initialization)
+9. Display Claude Code transition guide
 
 If no product planning content exists in the conversation, prompt the user to run a product planning flow first.
+
+Note: `.product-dev-active` is a session-local marker (gitignored by the plugin). Delete it if the project ever returns to planning-only mode.

package/hooks/hooks.json

@@ -0,0 +1,40 @@
+{
+  "description": "product-playbook hooks: auto-load planning state, detect off-topic / change-propagation prompts, and gate code-file writes during the planning phase.",
+  "hooks": {
+    "SessionStart": [
+      {
+        "matcher": "startup|resume",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/session-start-load-progress.py",
+            "timeout": 10
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/user-prompt-detect-topic-switch.py",
+            "timeout": 5
+          }
+        ]
+      }
+    ],
+    "PreToolUse": [
+      {
+        "matcher": "Write|Edit|MultiEdit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/pre-write-planning-gate.py",
+            "timeout": 5
+          }
+        ]
+      }
+    ]
+  }
+}

package/hooks/pre-write-planning-gate.py

@@ -0,0 +1,102 @@
+#!/usr/bin/env python3
+"""PreToolUse hook: gate code-file writes during the planning phase.
+
+The product-playbook plugin draws a hard line between PLANNING (produces
+docs) and DEVELOPMENT (produces code). Until the user runs `/product-dev`
+to enter the dev-handoff phase — which creates a `.product-dev-active`
+marker file — Claude should not be writing source code.
+
+This hook fires on Write / Edit / MultiEdit. If:
+  • a planning session is in progress (progress file exists, not complete)
+  • AND the dev-active marker is absent
+  • AND the target path looks like source code
+
+…it injects an advisory `systemMessage` reminding Claude to finish
+planning first. The hook does NOT block the tool call (permissionDecision
+remains unset / allowed) so the user retains an explicit override path.
+
+Doc/text files (.md, .txt, .json, etc.) are always allowed — those are
+expected planning artifacts.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import sys
+from pathlib import Path
+
+CODE_EXTENSIONS = {
+    ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs",
+    ".py", ".rb", ".php", ".go", ".rs", ".java", ".kt",
+    ".swift", ".cs", ".cpp", ".cc", ".c", ".h", ".hpp",
+    ".vue", ".svelte", ".scala", ".dart", ".m", ".mm",
+}
+
+WATCHED_TOOLS = {"Write", "Edit", "MultiEdit"}
+
+
+def _planning_in_progress(progress_file: Path) -> bool:
+    if not progress_file.is_file():
+        return False
+    try:
+        body = progress_file.read_text(encoding="utf-8", errors="ignore")
+    except OSError:
+        return False
+    lowered = body.lower()
+    if "status: complete" in lowered or "status：complete" in lowered:
+        return False
+    if re.search(r"status\s*[:：]\s*completed", lowered):
+        return False
+    return True
+
+
+def _target_path(tool_name: str, tool_input: dict) -> str | None:
+    if not isinstance(tool_input, dict):
+        return None
+    return tool_input.get("file_path") or tool_input.get("path")
+
+
+def main() -> int:
+    try:
+        payload = json.load(sys.stdin)
+    except (json.JSONDecodeError, ValueError):
+        return 0
+
+    tool_name = payload.get("tool_name")
+    if tool_name not in WATCHED_TOOLS:
+        return 0
+
+    cwd = Path(payload.get("cwd") or os.getcwd())
+
+    # Dev phase active → silent passthrough.
+    if (cwd / ".product-dev-active").is_file():
+        return 0
+
+    if not _planning_in_progress(cwd / ".product-playbook-progress.md"):
+        return 0
+
+    target = _target_path(tool_name, payload.get("tool_input") or {})
+    if not target:
+        return 0
+
+    suffix = Path(target).suffix.lower()
+    if suffix not in CODE_EXTENSIONS:
+        return 0
+
+    message = (
+        f"[product-playbook] Heads-up: '{target}' looks like source code, "
+        "but this project is still in the PLANNING phase (no "
+        "`.product-dev-active` marker). The plugin's contract is "
+        "planning-produces-docs, dev-produces-code. Recommended: finish "
+        "the current mode's remaining steps, then run `/product-dev` to "
+        "enter the dev-handoff phase. If the user has explicitly asked "
+        "for code now, acknowledge the override and proceed."
+    )
+    json.dump({"systemMessage": message}, sys.stdout)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/hooks/session-start-load-progress.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+"""SessionStart hook: auto-load product-playbook progress / context.
+
+Detects `.product-playbook-progress.md` and `.product-context.md` in the
+session's working directory. If either exists, their contents are injected
+as additional context so Claude can resume the planning flow without
+re-reading them manually.
+
+Hook contract:
+- Reads JSON payload from stdin (Claude Code provides session metadata).
+- On exit code 0, stdout is fed back to Claude as session context.
+- Silent (no output) when no playbook state is found, so non-PM projects
+  are unaffected.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+from pathlib import Path
+
+MAX_BYTES_PER_FILE = 16 * 1024  # cap each file to keep injected context small
+
+
+def _read_capped(path: Path) -> str | None:
+    try:
+        data = path.read_text(encoding="utf-8")
+    except OSError:
+        return None
+    if len(data) > MAX_BYTES_PER_FILE:
+        data = data[:MAX_BYTES_PER_FILE] + "\n... (truncated by hook)\n"
+    return data
+
+
+def main() -> int:
+    try:
+        payload = json.load(sys.stdin)
+    except (json.JSONDecodeError, ValueError):
+        payload = {}
+
+    cwd = payload.get("cwd") or os.getcwd()
+    cwd_path = Path(cwd)
+
+    targets = [
+        ("Planning progress", cwd_path / ".product-playbook-progress.md"),
+        ("Product context", cwd_path / ".product-context.md"),
+    ]
+
+    sections: list[str] = []
+    for label, path in targets:
+        if not path.is_file():
+            continue
+        body = _read_capped(path)
+        if body is None:
+            continue
+        sections.append(f"### {label} ({path.name})\n\n{body}")
+
+    if not sections:
+        return 0
+
+    header = (
+        "[product-playbook] Existing planning state was detected in this "
+        "project. Resume from where the user left off — do NOT restart from "
+        "step 1. Reference the snapshot below before responding."
+    )
+    additional_context = header + "\n\n" + "\n\n---\n\n".join(sections)
+
+    output = {
+        "hookSpecificOutput": {
+            "hookEventName": "SessionStart",
+            "additionalContext": additional_context,
+        }
+    }
+    json.dump(output, sys.stdout)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/hooks/user-prompt-detect-topic-switch.py

@@ -0,0 +1,123 @@
+#!/usr/bin/env python3
+"""UserPromptSubmit hook: detect off-topic prompts and change-propagation triggers.
+
+Two soft-reminder modes, both active only when a planning session is in
+progress (signalled by a `.product-playbook-progress.md` whose status is
+not "complete"):
+
+1. Off-topic detection — if the user prompt contains debug / error /
+   "explain this code" keywords, remind Claude to follow the off-topic
+   handling rule documented in SKILL.md (save progress before answering,
+   then offer the continue/pause/end menu).
+
+2. Change-propagation trigger — if the prompt contains keywords that
+   suggest revising an earlier step (e.g. "改 step 2", "update persona",
+   "重做 JTBD"), remind Claude to apply
+   `references/rules-change-propagation.md` so downstream artifacts stay
+   consistent.
+
+Both reminders are advisory: the hook never blocks the user prompt. It
+emits a JSON `systemMessage` that surfaces in Claude's context.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import sys
+from pathlib import Path
+
+OFF_TOPIC_PATTERNS = [
+    r"\bdebug\b",
+    r"\berror\b",
+    r"\bstack[\s\-]?trace\b",
+    r"\bexception\b",
+    r"\btraceback\b",
+    r"報錯",
+    r"錯誤訊息",
+    r"報錯訊息",
+    r"为什么这段",
+    r"為什麼這段",
+    r"幫我寫.*(code|程式|代碼)",
+    r"幫我改.*(code|程式|代碼)",
+    r"why does this code",
+    r"fix this (bug|code|function)",
+]
+
+CHANGE_PROPAGATION_PATTERNS = [
+    r"改\s*(step|步驟|S\d)",
+    r"重做\s*(step|步驟|S\d|JTBD|Persona|MVP|North\s*Star)",
+    r"重新\s*(做|寫|算).*(step|步驟|JTBD|Persona|MVP)",
+    r"修改.*(step|步驟|JTBD|Persona|MVP|North\s*Star)",
+    r"\bupdate\s+(step|persona|jtbd|mvp|north\s*star)",
+    r"\brewrite\s+(step|persona|jtbd|mvp)",
+    r"\bredo\s+(step|persona|jtbd|mvp)",
+    r"\bchange\s+(step|persona|jtbd|mvp|north\s*star)",
+]
+
+
+def _planning_in_progress(progress_file: Path) -> bool:
+    if not progress_file.is_file():
+        return False
+    try:
+        body = progress_file.read_text(encoding="utf-8", errors="ignore")
+    except OSError:
+        return False
+    lowered = body.lower()
+    if "status: complete" in lowered or "status：complete" in lowered:
+        return False
+    if re.search(r"status\s*[:：]\s*completed", lowered):
+        return False
+    return True
+
+
+def _matches_any(prompt: str, patterns: list[str]) -> bool:
+    return any(re.search(p, prompt, re.IGNORECASE) for p in patterns)
+
+
+def main() -> int:
+    try:
+        payload = json.load(sys.stdin)
+    except (json.JSONDecodeError, ValueError):
+        return 0
+
+    prompt = (payload.get("user_prompt") or "").strip()
+    if not prompt:
+        return 0
+
+    cwd = payload.get("cwd") or os.getcwd()
+    progress = Path(cwd) / ".product-playbook-progress.md"
+    if not _planning_in_progress(progress):
+        return 0
+
+    reminders: list[str] = []
+
+    if _matches_any(prompt, OFF_TOPIC_PATTERNS):
+        reminders.append(
+            "[product-playbook] Off-topic prompt detected during an active "
+            "planning session. Before answering, follow the rule in "
+            "SKILL.md > 'Off-topic Prompt Handling': (1) save progress to "
+            "`.product-playbook-progress.md` per `references/rules-progress.md`, "
+            "(2) answer the question, (3) append the Continue / Pause / End "
+            "menu so the user can return to the flow."
+        )
+
+    if _matches_any(prompt, CHANGE_PROPAGATION_PATTERNS):
+        reminders.append(
+            "[product-playbook] Change intent detected. Apply "
+            "`references/rules-change-propagation.md`: identify which "
+            "downstream tables depend on the modified step, update them in "
+            "lock-step, and surface the propagation summary to the user."
+        )
+
+    if not reminders:
+        return 0
+
+    output = {"systemMessage": "\n\n".join(reminders)}
+    json.dump(output, sys.stdout)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "product-playbook",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "description": "MUST use when user wants to plan or strategize a product/feature. 22 PM frameworks, 6 modes, from idea to dev handoff",
   "bin": {
     "product-playbook": "./install.sh"
@@ -31,6 +31,7 @@
     "install.sh",
     "SKILL.md",
     "commands/",
+    "hooks/",
     "references/",
     "i18n/",
     "README.zh-TW.md",