cokit-cli 1.2.7 → 1.4.0

package/skills/ck-planning/references/validate-workflow.md

@@ -0,0 +1,65 @@
+# Validate Workflow
+
+Interview the user with critical questions to validate assumptions, confirm decisions, and surface potential issues in an implementation plan before coding begins.
+
+## Plan Resolution
+
+1. If `$ARGUMENTS` provided → Use that path
+2. Else check `## Plan Context` section → Use active plan path
+3. If no plan found → Ask user to specify path or run `/ck-plan --hard` first
+
+## Configuration
+
+Check `## Plan Context` section for validation settings:
+- `mode` - Controls auto/prompt/off behavior
+- `questions` - Range like `3-8` (min-max)
+
+## Workflow
+
+### Step 1: Read Plan Files
+- `plan.md` - Overview and phases list
+- `phase-*.md` - All phase files
+- Look for decision points, assumptions, risks, tradeoffs
+
+### Step 2: Extract Question Topics
+Load: `references/validate-question-framework.md`
+
+### Step 3: Generate Questions
+For each detected topic, formulate a concrete question with 2-4 options.
+Mark recommended option with "(Recommended)" suffix.
+
+### Step 4: Interview User
+Use asking the user tool.
+- Use question count from `## Plan Context` validation settings
+- Group related questions (max 4 per tool call)
+- Focus on: assumptions, risks, tradeoffs, architecture
+
+### Step 5: Document Answers
+Add or append `## Validation Log` section in `plan.md`.
+Load: `references/validate-question-framework.md` for recording format.
+
+### Step 6: Propagate Changes to Phases
+Auto-propagate validation decisions to affected phase files.
+Add marker: `<!-- Updated: Validation Session N - {change} -->`
+
+## Output
+- Number of questions asked
+- Key decisions confirmed
+- Phase propagation results
+- Recommendation: proceed or revise
+
+## Next Steps (MANDATORY)
+Remind user with absolute path:
+> **Best Practice:** Run `/clear` before implementing to start with fresh context.
+> Then run:
+> ```
+> /ck-cook --auto {ABSOLUTE_PATH_TO_PLAN_DIR}/plan.md
+> ```
+> **Why `--auto`?** Plan was already validated — safe to skip review gates.
+> **Why absolute path?** After `/clear`, the new session loses previous context.
+> Fresh context helps focus solely on implementation without planning context pollution.
+
+## Important Notes
+- Only ask about genuine decision points
+- If plan is simple, fewer than min questions is okay
+- Prioritize questions that could change implementation significantly

package/skills/ck-planning/references/workflow-modes.md

@@ -0,0 +1,154 @@
+# Workflow Modes
+
+## Auto-Detection (Default: `--auto`)
+
+When no flag specified, analyze task and pick mode:
+
+| Signal | Mode | Rationale |
+|--------|------|-----------|
+| Simple task, clear scope, no unknowns | fast | Skip research overhead |
+| Complex task, unfamiliar domain, new tech | hard | Research needed |
+| 3+ independent features/layers/modules | parallel | Enable concurrent agents |
+| Ambiguous approach, multiple valid paths | two | Compare alternatives |
+
+Use asking the user if detection is uncertain.
+
+## Scope Challenge Integration
+
+Step 0 (Scope Challenge, see `scope-challenge.md`) runs before mode detection and can influence it:
+- If user selects **EXPANSION** → auto-suggest `--hard` or `--two`
+- If user selects **REDUCTION** → auto-suggest `--fast`
+- If user selects **HOLD** → proceed with auto-detected mode
+
+Mode can still be overridden by explicit flags (`--fast`, `--hard`, etc.).
+Scope challenge is skipped when `--fast` is explicitly set or task is trivial.
+
+## Fast Mode (`--fast`)
+
+No research. Analyze → Plan → Hydrate Tasks.
+
+1. Read codebase docs (`codebase-summary.md`, `code-standards.md`, `system-architecture.md`)
+2. Use `ck-planner` subagent to create plan
+3. Hydrate tasks (unless `--no-tasks`)
+4. **Context reminder:** `/ck-cook --auto {absolute-plan-path}/plan.md`
+
+**Why `--auto` cook flag?** Fast planning pairs with fast execution — skip review gates.
+
+## Hard Mode (`--hard`)
+
+Research → Scout → Plan → Red Team → Validate → Hydrate Tasks.
+
+1. Spawn max 2 `ck-researcher` agents in parallel (different aspects, max 5 calls each)
+2. Read codebase docs; if stale/missing: run `/ck-scout` to search codebase
+3. Gather research + scout report filepaths → pass to `ck-planner` subagent
+4. Post-plan red team review (see Red Team Review section below)
+5. Post-plan validation (see Validation section below)
+6. Hydrate tasks (unless `--no-tasks`)
+7. **Context reminder:** `/ck-cook {absolute-plan-path}/plan.md`
+
+**Why no cook flag?** Thorough planning needs interactive review gates.
+
+## Parallel Mode (`--parallel`)
+
+Research → Scout → Plan with file ownership → Red Team → Validate → Hydrate Tasks with dependency graph.
+
+1. Same as Hard mode steps 1-3
+2. Planner creates phases with:
+   - **Exclusive file ownership** per phase (no overlap)
+   - **Dependency matrix** (which phases run concurrently vs sequentially)
+   - **Conflict prevention** strategy
+3. plan.md includes: dependency graph, execution strategy, file ownership matrix
+4. Hydrate tasks: `addBlockedBy` for sequential deps, no blockers for parallel groups
+5. Post-plan red team review
+6. Post-plan validation
+7. **Context reminder:** `/ck-cook --parallel {absolute-plan-path}/plan.md`
+
+### Parallel Phase Requirements
+- Each phase self-contained, no runtime deps on other phases
+- Clear file boundaries — each file modified in ONE phase only
+- Group by: architectural layer, feature domain, or technology stack
+- Example: Phases 1-3 parallel (DB/API/UI), Phase 4 sequential (integration tests)
+
+## Two-Approach Mode (`--two`)
+
+Research → Scout → Plan 2 approaches → Compare → Hydrate Tasks.
+
+1. Same as Hard mode steps 1-3
+2. Planner creates 2 implementation approaches with:
+   - Clear trade-offs (pros/cons each)
+   - Recommended approach with rationale
+3. User selects approach
+4. Post-plan red team review on selected approach
+5. Post-plan validation
+6. Hydrate tasks for selected approach (unless `--no-tasks`)
+7. **Context reminder:** `/ck-cook {absolute-plan-path}/plan.md`
+
+## Task Hydration Per Mode
+
+| Mode | Task Granularity | Dependency Pattern |
+|------|------------------|--------------------|
+| fast | Phase-level only | Sequential chain |
+| hard | Phase + critical steps | Sequential + step deps |
+| parallel | Phase + steps + ownership | Parallel groups + sequential deps |
+| two | After user selects approach | Sequential chain |
+
+All modes: See `task-management.md` for TaskCreate patterns and metadata.
+
+## Post-Plan Red Team Review
+
+Adversarial review that spawns hostile reviewers to find flaws before validation.
+
+**Available in:** hard, parallel, two modes. **Skipped in:** fast mode.
+
+**Invocation:** Run `/ck-plan red-team {plan-directory-path}`.
+```
+/ck-plan red-team {plan-directory-path}
+```
+
+**Sequence:** Red team runs BEFORE validation because:
+1. Red team may change the plan (added risks, removed sections, new constraints)
+2. Validation should confirm the FINAL plan, not a pre-review draft
+3. Validating first then red-teaming would invalidate validation answers
+
+## Post-Plan Validation
+
+Check `## Plan Context` → `Validation: mode=X, questions=MIN-MAX`:
+
+| Mode | Behavior |
+|------|----------|
+| `prompt` | Ask: "Validate this plan with interview?" → Yes (Recommended) / No |
+| `auto` | Run `/ck-plan validate {plan-directory-path}` |
+| `off` | Skip validation |
+
+**Invocation (when prompt mode, user says yes):** Run:
+```
+/ck-plan validate {plan-directory-path}
+```
+
+**Available in:** hard, parallel, two modes. **Skipped in:** fast mode.
+
+## Context Reminder (MANDATORY)
+
+After plan creation, MUST output with **actual absolute path**:
+
+| Mode | Cook Command |
+|------|-----------------------------|
+| fast | `/ck-cook --auto {path}/plan.md` |
+| hard | `/ck-cook {path}/plan.md` |
+| parallel | `/ck-cook --parallel {path}/plan.md` |
+| two | `/ck-cook {path}/plan.md` |
+
+> **Best Practice:** Run `/clear` before implementing to reduce planning-context carryover.
+> Then run the cook command above.
+
+**Why absolute path?** After `/clear`, the new session loses previous context.
+This reminder is **NON-NEGOTIABLE** — always output after presenting the plan.
+
+## Pre-Creation Check
+
+Check `## Plan Context` in injected context:
+- **"Plan: {path}"** → Ask "Continue with existing plan? [Y/n]"
+- **"Suggested: {path}"** → Branch hint only, ask if activate or create new
+- **"Plan: none"** → Create new using `Plan dir:` from `## Naming`
+
+Pass plan directory path to every subagent during the process.

package/skills/ck-problem-solving/SKILL.md

@@ -0,0 +1,96 @@
+---
+name: ck-problem-solving
+description: Apply systematic problem-solving techniques when stuck. Use for complexity spirals, innovation blocks, recurring patterns, assumption constraints, simplification cascades, scale uncertainty.
+argument-hint: "[problem description]"
+---
+
+# Problem-Solving Techniques
+
+Systematic approaches for different types of stuck-ness. Each technique targets specific problem patterns.
+
+## When to Use
+
+Apply when encountering:
+- **Complexity spiraling** - Multiple implementations, growing special cases, excessive branching
+- **Innovation blocks** - Conventional solutions inadequate, need breakthrough thinking
+- **Recurring patterns** - Same issue across domains, reinventing solutions
+- **Assumption constraints** - Forced into "only way", can't question premise
+- **Scale uncertainty** - Production readiness unclear, edge cases unknown
+- **General stuck-ness** - Unsure which technique applies
+
+## Quick Dispatch
+
+**Match symptom to technique:**
+
+| Stuck Symptom | Technique | Reference |
+|---------------|-----------|-----------|
+| Same thing implemented 5+ ways, growing special cases | **Simplification Cascades** | `references/simplification-cascades.md` |
+| Conventional solutions inadequate, need breakthrough | **Collision-Zone Thinking** | `references/collision-zone-thinking.md` |
+| Same issue in different places, reinventing wheels | **Meta-Pattern Recognition** | `references/meta-pattern-recognition.md` |
+| Solution feels forced, "must be done this way" | **Inversion Exercise** | `references/inversion-exercise.md` |
+| Will this work at production? Edge cases unclear? | **Scale Game** | `references/scale-game.md` |
+| Unsure which technique to use | **When Stuck** | `references/when-stuck.md` |
+
+## Core Techniques
+
+### 1. Simplification Cascades
+Find one insight eliminating multiple components. "If this is true, we don't need X, Y, Z."
+
+**Key insight:** Everything is a special case of one general pattern.
+
+**Red flag:** "Just need to add one more case..." (repeating forever)
+
+### 2. Collision-Zone Thinking
+Force unrelated concepts together to discover emergent properties. "What if we treated X like Y?"
+
+**Key insight:** Revolutionary ideas from deliberate metaphor-mixing.
+
+**Red flag:** "I've tried everything in this domain"
+
+### 3. Meta-Pattern Recognition
+Spot patterns appearing in 3+ domains to find universal principles.
+
+**Key insight:** Patterns in how patterns emerge reveal reusable abstractions.
+
+**Red flag:** "This problem is unique" (probably not)
+
+### 4. Inversion Exercise
+Flip core assumptions to reveal hidden constraints. "What if the opposite were true?"
+
+**Key insight:** Valid inversions reveal context-dependence of "rules."
+
+**Red flag:** "There's only one way to do this"
+
+### 5. Scale Game
+Test at extremes (1000x bigger/smaller, instant/year-long) to expose fundamental truths.
+
+**Key insight:** What works at one scale fails at another.
+
+**Red flag:** "Should scale fine" (without testing)
+
+## Application Process
+
+1. **Identify stuck-type** - Match symptom to technique above
+2. **Load detailed reference** - Read specific technique from `references/`
+3. **Apply systematically** - Follow technique's process
+4. **Document insights** - Record what worked/failed
+5. **Combine if needed** - Some problems need multiple techniques
+
+## Combining Techniques
+
+Powerful combinations:
+- **Simplification + Meta-pattern** - Find pattern, then simplify all instances
+- **Collision + Inversion** - Force metaphor, then invert its assumptions
+- **Scale + Simplification** - Extremes reveal what to eliminate
+- **Meta-pattern + Scale** - Universal patterns tested at extremes
+
+## References
+
+Load detailed guides as needed:
+- `references/when-stuck.md` - Dispatch flowchart and decision tree
+- `references/simplification-cascades.md` - Cascade detection and extraction
+- `references/collision-zone-thinking.md` - Metaphor collision process
+- `references/meta-pattern-recognition.md` - Pattern abstraction techniques
+- `references/inversion-exercise.md` - Assumption flipping methodology
+- `references/scale-game.md` - Extreme testing procedures
+- `references/attribution.md` - Source and adaptation notes

package/skills/ck-project-management/SKILL.md

@@ -0,0 +1,133 @@
+---
+name: ck-project-management
+description: "Track progress, update plan statuses, manage Tasks, generate reports, coordinate docs updates. Use for project oversight, status checks, plan completion, task hydration, cross-session continuity."
+argument-hint: "[task: status, hydrate, sync, report]"
+---
+
+# Project Management
+
+Project oversight and coordination using native Tasks with persistent plan files.
+
+**Principles:** Token efficiency | Concise reports | Data-driven insights
+
+## When to Use
+
+- Checking project status or progress across plans
+- Updating plan statuses after feature completion
+- Hydrating/syncing Tasks with plan files
+- Generating status reports or summaries
+- Coordinating documentation updates after milestones
+- Verifying task completeness against acceptance criteria
+- Cross-session resume of multi-phase work
+
+## Tool Availability
+
+`TaskCreate`, `TaskUpdate`, `TaskGet`, `TaskList` are **CLI-only** — disabled in VSCode extension (`isTTY` check).
+
+| Environment | Task Tools | Fallback |
+|-------------|-----------|----------|
+| CLI terminal | Available | — |
+| VSCode extension | **Disabled** | `TodoWrite` |
+
+**Fallback behavior:** If Task tools error, use `TodoWrite` for progress tracking. Plan file sync-back (checkbox updates, YAML frontmatter) works identically without Task tools. Core PM workflow remains functional.
+
+## Core Capabilities
+
+### 1. Task Operations
+Load: `references/task-operations.md`
+
+Use `TaskCreate`, `TaskUpdate`, `TaskGet`, `TaskList` to manage session-scoped tasks (CLI only; see Tool Availability above).
+- Create tasks with metadata (phase, priority, effort, planDir, phaseFile)
+- Track status: `pending` → `in_progress` → `completed`
+- Manage dependencies with `addBlockedBy` / `addBlocks`
+- Coordinate parallel agents with scoped ownership
+
+### 2. Session Bridging (Hydration Pattern)
+Load: `references/hydration-workflow.md`
+
+Tasks are ephemeral. Plan files are persistent. The hydration pattern bridges them:
+- **Hydrate:** Read plan `[ ]` items → `TaskCreate` per unchecked item
+- **Work:** `TaskUpdate` tracks progress in real-time
+- **Sync-back:** Reconcile all completed tasks against all phase files, update `[ ]` → `[x]`, update YAML frontmatter status
+- **Resume:** Next session re-hydrates from remaining `[ ]` items
+
+### 3. Progress Tracking
+Load: `references/progress-tracking.md`
+
+- Scan `./plans/*/plan.md` for active plans
+- Parse YAML frontmatter for status, priority, effort
+- Count `[x]` vs `[ ]` in phase files for completion %
+- Cross-reference completed work against planned tasks
+- Verify acceptance criteria met before marking complete
+
+### 4. Documentation Coordination
+Load: `references/documentation-triggers.md`
+
+Trigger `./docs` updates when:
+- Phase status changes, major features complete
+- API contracts change, architecture decisions made
+- Security patches applied, breaking changes occur
+
+Delegate to `ck-docs-manager` subagent for actual updates.
+
+### 5. Status Reporting
+Load: `references/reporting-patterns.md`
+
+Generate reports: session summaries, plan completion, multi-plan overviews.
+- Use naming: `{reports-path}/pm-{date}-{time}-{slug}.md`
+- Sacrifice grammar for brevity; use tables over prose
+- List unresolved questions at end
+
+## Workflow
+
+```
+[Scan Plans] → [Hydrate Tasks] → [Track Progress] → [Update Status] → [Generate Report] → [Trigger Doc Updates]
+```
+
+1. `TaskList()` — check existing tasks first
+2. If empty: hydrate from plan files (unchecked items)
+3. During work: `TaskUpdate` as tasks progress
+4. On completion: run full-plan sync-back (all phase files, including backfill for earlier phases), then update YAML frontmatter
+5. Generate status report to reports directory
+6. Delegate doc updates if changes warrant
+
+## Mandatory Sync-Back Guard
+
+When updating plan status, NEVER mark only the currently active phase.
+
+1. Sweep all `phase-XX-*.md` files under the target plan directory.
+2. Reconcile every `TaskUpdate(status: "completed")` item to phase metadata (`phase` / `phaseFile`).
+3. Backfill stale checkboxes in earlier phases before marking later phases done.
+4. Update `plan.md` status/progress from real checkbox counts.
+5. If any completed task cannot be mapped to a phase file, report unresolved mappings and do not claim full completion.
+
+## Plan YAML Frontmatter
+
+All `plan.md` files MUST have:
+
+```yaml
+---
+title: Feature name
+status: in-progress  # pending | in-progress | completed
+priority: P1
+effort: medium
+branch: feature-branch
+tags: [auth, api]
+created: 2026-02-05
+---
+```
+
+Update `status` when plan state changes.
+
+## Quality Standards
+
+- All analysis data-driven, referencing specific plans and reports
+- Focus on business value delivery and actionable insights
+- Highlight critical issues requiring immediate attention
+- Maintain traceability between requirements and implementation
+
+## Related Skills
+
+- `plan` — Creates implementation plans (planning phase)
+- `ck-cook` — Implements plans (execution phase, invokes project-manager at finalize)
+- `plans-kanban` — Visual dashboard for plan viewing

package/skills/ck-project-management/references/documentation-triggers.md

@@ -0,0 +1,60 @@
+# Documentation Triggers
+
+## When to Update Docs
+
+MUST update project documentation in `./docs` when:
+
+| Trigger | Which Docs | Action |
+|---------|-----------|--------|
+| Phase status changes | project-roadmap.md | Update progress %, milestone status |
+| Major feature complete | project-roadmap.md, codebase-summary.md | Add feature, update architecture |
+| Bug fix (significant) | project-roadmap.md | Document fix, severity, impact |
+| Security patch | project-roadmap.md, system-architecture.md | Record improvement |
+| API contract changes | system-architecture.md, code-standards.md | Update endpoints, schemas |
+| Architecture decision | system-architecture.md | Document decision + rationale |
+| Scope/timeline change | project-roadmap.md | Adjust phases, dates |
+| Dependencies updated | system-architecture.md | Record version changes |
+| Breaking changes | code-standards.md | Document migration path |
+
+## Documentation Files
+
+```
+./docs/
+├── project-overview-pdr.md     # Product requirements
+├── code-standards.md           # Coding conventions
+├── codebase-summary.md         # Architecture overview
+├── design-guidelines.md        # UI/UX standards
+├── deployment-guide.md         # Deploy procedures
+├── system-architecture.md      # System design
+└── project-roadmap.md          # Milestones & progress
+```
+
+## Update Protocol
+
+1. **Read current state:** Always read target doc before editing
+2. **Analyze reports:** Review agent reports in plan reports directory
+3. **Update content:** Modify progress %, statuses, dates, descriptions
+4. **Cross-reference:** Ensure consistency across docs
+5. **Validate:** Verify dates, versions, references accurate
+
+## Quality Standards
+
+- **Consistency:** Same formatting, versioning across all docs
+- **Accuracy:** Progress %, dates, statuses reflect reality
+- **Completeness:** Sufficient detail for stakeholder communication
+- **Timeliness:** Update within same session as significant changes
+- **Traceability:** Clear links between roadmap items and implementation
+
+## Delegation Pattern
+
+Use `ck-docs-manager` subagent for documentation updates:
+
+```
+Task(
+  subagent_type: "docs-manager",
+  prompt: "Update ./docs for [changes]. Work context: [path]",
+  description: "Update docs"
+)
+```
+
+Project manager coordinates WHEN to update; docs-manager handles HOW.

package/skills/ck-project-management/references/hydration-workflow.md

@@ -0,0 +1,89 @@
+# Hydration Workflow
+
+Tasks are **session-scoped** — they disappear when the session ends. Plan files are the **persistent** layer. The hydration pattern bridges sessions.
+
+## Flow Diagram
+
+```
+┌──────────────────┐  Hydrate   ┌───────────────────┐
+│ Plan Files       │ ─────────► │ Tasks      │
+│ (persistent)     │            │ (session-scoped)  │
+│ [ ] Phase 1      │            │ ◼ pending         │
+│ [ ] Phase 2      │            │ ◼ pending         │
+└──────────────────┘            └───────────────────┘
+                                        │ Work
+                                        ▼
+┌──────────────────┐  Sync-back ┌───────────────────┐
+│ Plan Files       │ ◄───────── │ Task Updates      │
+│ (updated)        │            │ (completed)       │
+│ [x] Phase 1      │            │ ✓ completed       │
+│ [ ] Phase 2      │            │ ◼ in_progress     │
+└──────────────────┘            └───────────────────┘
+```
+
+## Tool Availability
+
+Task tools (`TaskCreate`/`TaskUpdate`/`TaskGet`/`TaskList`) are **CLI-only** — disabled in VSCode extension. If unavailable, use `TodoWrite` for progress tracking. The hydration pattern still works: plan files remain source of truth, sync-back updates checkboxes regardless of Task tool availability.
+
+## Session Start: Hydration
+
+1. Read plan files: `plan.md` + `phase-XX-*.md`
+2. Identify unchecked `[ ]` items = remaining work
+3. `TaskCreate` per unchecked item with metadata (phase, priority, effort, planDir, phaseFile) — or `TodoWrite` if Task tools unavailable
+4. Set up `addBlockedBy` dependency chains between phases (skip if using TodoWrite fallback)
+5. Already-checked `[x]` items = done, skip
+
+**Check first:** `TaskList()` — if tasks already exist (same session), skip re-creation. If TaskList errors, proceed with TodoWrite.
+
+## During Work
+
+- `TaskUpdate(status: "in_progress")` when picking up a task
+- `TaskUpdate(status: "completed")` immediately after finishing
+- Parallel agents coordinate through shared task list
+- Blocked tasks auto-unblock when dependencies complete
+
+## Session End: Sync-Back
+
+1. Collect completed tasks (`TaskUpdate(status: "completed")`) with metadata (`phase`, `phaseFile`, `planDir`).
+2. Sweep all `phase-XX-*.md` files in the target plan directory.
+3. Reconcile and backfill: update `[ ]` → `[x]` for all completed items across every phase file (including earlier phases).
+4. Update `plan.md` frontmatter: status field (pending → in-progress → completed).
+5. Update progress percentages in `plan.md` overview from real checkbox counts.
+6. Report unresolved mappings when completed tasks cannot be matched to a phase file.
+7. Git commit captures state transition for next session.
+
+## Cross-Session Resume
+
+When user runs `/ck-cook path/to/plan.md` in a new session:
+1. `TaskList()` → empty (tasks died with old session)
+2. Read plan files → re-hydrate from unchecked `[ ]` items
+3. Already-checked `[x]` = done, creates tasks only for remaining work
+4. Dependency chain reconstructed automatically
+
+## Compound Interest Effect
+
+Each hydration cycle makes specs smarter:
+- **Session 1:** Execute first tasks, establish patterns
+- **Session 2:** See completed work, build on established patterns
+- **Session 3:** Full context of prior sessions, fewer clarifications needed
+
+Git history shows progression. Completed checkboxes show the path that worked. Specs gain **institutional memory** across sessions.
+
+## YAML Frontmatter Sync
+
+Plan files MUST have frontmatter with these fields:
+
+```yaml
+---
+title: Feature name
+description: Brief description
+status: in-progress  # pending | in-progress | completed
+priority: P1
+effort: medium
+branch: feature-branch
+tags: [auth, api]
+created: 2026-02-05
+---
+```
+
+Update `status` field during sync-back when plan state changes.