cokit-cli 1.2.6 → 1.3.0

package/skills/cook/README.md

@@ -4,15 +4,15 @@ End-to-end feature implementation with smart intent detection.
 
 ## Installation
 
-Copy the `cook/` folder to your skills directory:
+Install via CoKit CLI:
 ```bash
-cp -r cook ~/.copilot/skills/
+# Install via: npx cokit-cli init
 ```
 
 ## Usage
 
 ```bash
-/cook <natural language task OR plan path>
+/ck-cook <natural language task OR plan path>
 ```
 
 The skill automatically detects your intent and routes to the appropriate workflow.
@@ -21,25 +21,25 @@ The skill automatically detects your intent and routes to the appropriate workfl
 
 ```bash
 # Interactive mode (default)
-/cook implement user authentication
+/ck-cook implement user authentication
 
 # Execute existing plan
-/cook plans/260120-auth
+/ck-cook plans/260120-auth
 
 # Fast mode (skip research)
-/cook quick fix for login bug
-/cook implement feature --fast
+/ck-cook quick fix for login bug
+/ck-cook implement feature --fast
 
 # Auto mode (trust me bro)
-/cook implement dashboard trust me
-/cook implement feature --auto
+/ck-cook implement dashboard trust me
+/ck-cook implement feature --auto
 
 # Parallel mode (multi-agent)
-/cook implement auth, payments, notifications
-/cook implement feature --parallel
+/ck-cook implement auth, payments, notifications
+/ck-cook implement feature --parallel
 
 # No-test mode
-/cook implement feature --no-test
+/ck-cook implement feature --no-test
 ```
 
 ## Modes
@@ -77,7 +77,7 @@ cook/
     ├── intent-detection.md            # Detection rules
     ├── workflow-steps.md              # Step definitions
     ├── review-cycle.md                # Review process
-    └── agent-patterns.md               # Agent usage
+    └── subagent-patterns.md           # Subagent usage
 ```
 
 ## Version

package/skills/cook/SKILL.md

@@ -1,6 +1,7 @@
 ---
 name: cook
-description: ALWAYS activate this skill before implementing EVERY feature, plan, or fix.
+description: "ALWAYS activate this skill before implementing EVERY feature, plan, or fix."
+argument-hint: "[task|plan-path] [--interactive|--fast|--parallel|--auto|--no-test]"
 ---
 
 # Cook - Smart Feature Implementation
@@ -12,18 +13,42 @@ End-to-end implementation with automatic workflow detection.
 ## Usage
 
 ```
-/cook <natural language task OR plan path>
+/ck-cook <natural language task OR plan path>
 ```
 
-**Optional flags:** `--fast`, `--parallel`, `--no-test`, `--auto`, `--interactive`
+**IMPORTANT:** If no flag is provided, the skill will use the `interactive` mode by default for the workflow.
 
-Example:
+**Optional flags to select the workflow mode:** 
+- `--interactive`: Full workflow with user input (**default**)
+- `--fast`: Skip research, scout→plan→code
+- `--parallel`: Multi-agent execution
+- `--no-test`: Skip testing step
+- `--auto`: Auto-approve all steps
+
+**Example:**
 ```
-/cook "Add user authentication to the app" --fast
-/cook path/to/plan.md --auto
-/cook "Fix login bug" --interactive
+/ck-cook "Add user authentication to the app" --fast
+/ck-cook path/to/plan.md --auto
 ```
 
+<HARD-GATE>
+Do NOT write implementation code until a plan exists and has been reviewed.
+This applies regardless of task simplicity. "Simple" tasks are where unexamined assumptions waste the most time.
+Exception: `--fast` mode skips research but still requires a plan step.
+User override: If user explicitly says "just code it" or "skip planning", respect their instruction.
+</HARD-GATE>
+
+## Anti-Rationalization
+
+| Thought | Reality |
+|---------|---------|
+| "This is too simple to plan" | Simple tasks have hidden complexity. Plan takes 30 seconds. |
+| "I already know how to do this" | Knowing ≠ planning. Write it down. |
+| "Let me just start coding" | Undisciplined action wastes tokens. Plan first. |
+| "The user wants speed" | Fastest path = plan → implement → done. Not: implement → debug → rewrite. |
+| "I'll plan as I go" | That's not planning, that's hoping. |
+| "Just this once" | Every skip is "just this once." No exceptions. |
+
 ## Smart Intent Detection
 
 | Input Pattern | Detected Mode | Behavior |
@@ -33,11 +58,34 @@ Example:
 | Contains "trust me", "auto" | auto | Auto-approve all steps |
 | Lists 3+ features OR "parallel" | parallel | Multi-agent execution |
 | Contains "no test", "skip test" | no-test | Skip testing step |
-| `--interactive` flag (explicit) | interactive | Full workflow with user input |
 | Default | interactive | Full workflow with user input |
 
 See `references/intent-detection.md` for detection logic.
 
+## Process Flow (Authoritative)
+
+```mermaid
+flowchart TD
+    A[Intent Detection] --> B{Has plan path?}
+    B -->|Yes| F[Load Plan]
+    B -->|No| C{Mode?}
+    C -->|fast| D[Scout → Plan → Code]
+    C -->|interactive/auto| E[Research → Review → Plan]
+    E --> F
+    D --> F
+    F --> G[Review Gate]
+    G -->|approved| H[Implement]
+    G -->|rejected| E
+    H --> I[Review Gate]
+    I -->|approved| J{--no-test?}
+    J -->|No| K[Test]
+    J -->|Yes| L[Finalize]
+    K --> L
+    L --> M[Report + Journal]
+```
+
+**This diagram is the authoritative workflow.** Prose sections below provide detail for each node. If prose conflicts with this flow, follow the diagram.
+
 ## Workflow Overview
 
 ```
@@ -46,15 +94,16 @@ See `references/intent-detection.md` for detection logic.
 
 **Default (non-auto):** Stops at `[Review]` gates for human approval before each major step.
 **Auto mode (`--auto`):** Skips human review gates, implements all phases continuously.
+**Tasks:** Utilize `TaskCreate`, `TaskUpdate`, `TaskGet`, `TaskList` during implementation step. **Fallback:** These are CLI-only tools — unavailable in VSCode extension. If they error, use `TodoWrite` for progress tracking instead.
 
 | Mode | Research | Testing | Review Gates | Phase Progression |
 |------|----------|---------|--------------|-------------------|
 | interactive | ✓ | ✓ | **User approval at each step** | One at a time |
 | auto | ✓ | ✓ | Auto if score≥9.5 | All at once (no stops) |
-| fast | ✗ | ✓ | User approval at each step | One at a time |
-| parallel | Optional | ✓ | User approval at each step | Parallel groups |
-| no-test | ✓ | ✗ | User approval at each step | One at a time |
-| code | ✗ | ✓ | User approval at each step | Per plan |
+| fast | ✗ | ✓ | **User approval at each step** | One at a time |
+| parallel | Optional | ✓ | **User approval at each step** | Parallel groups |
+| no-test | ✓ | ✗ | **User approval at each step** | One at a time |
+| code | ✗ | ✓ | **User approval at each step** | Per plan |
 
 ## Step Output Format
 
@@ -73,55 +122,34 @@ Human review required at these checkpoints (skipped with `--auto`):
 **Always enforced (all modes):**
 - **Testing:** 100% pass required (unless no-test mode)
 - **Code Review:** User approval OR auto-approve (score≥9.5, 0 critical)
-- **Finalize:** docs-manager MUST complete
-
-## Required Agents
-
-| Phase | Agent | Requirement |
-|-------|-------|-------------|
-| Research | `researcher` agent (parallel, optional in fast) | Spawn as needed |
-| Scout | `scout` agent | Spawn for codebase search |
-| Plan | `planner` agent | MUST spawn |
-| UI Work | `ui-ux-designer` agent | Spawn when frontend work exists |
-| Testing | `tester`, `debugger` agents | MUST spawn |
-| Review | `code-reviewer` agent | MUST spawn |
-| Finalize | `docs-manager`, `git-manager` agents | MUST spawn |
-
-## Implementation Progress Tracking
-
-During Step 3 (Implementation), track progress using a todo list/checklist in the active plan or phase file:
-
-```
-- [ ] Phase 1: Setup environment
-- [ ] Phase 2: Database models
-- [ ] Phase 3: API endpoints
-- [ ] Phase 4: UI components
-```
-
-Update each item as completed. This replaces task management tooling with simple markdown tracking visible in the plan.
-
-## CRITICAL ENFORCEMENT
-
-**Steps 4 (Testing), 5 (Code Review), and 6 (Finalize) MUST delegate to agents. DO NOT implement testing, review, or finalization yourself.**
-
-- Step 4: Always delegate to `tester` agent. If failures, delegate to `debugger` agent, then re-delegate to `tester`.
-- Step 5: Always delegate to `code-reviewer` agent. Never self-review.
-- Step 6: Always delegate to `docs-manager` agent for doc updates.
-
-## Finalize Step (MANDATORY)
-
-Step 6 is not optional. All four actions MUST complete:
-
-1. Update plan/phase status to completed in plan files
-2. Delegate to `docs-manager` agent → review and update `./docs` if implementation changed APIs, architecture, or behavior
-3. Mark all todo checklist items complete in the active plan
-4. Ask the user: "Would you like to commit these changes via `git-manager` agent?"
-
-**Never skip finalize**, even in fast or auto mode.
+- **Finalize (MANDATORY - never skip):**
+  1. `project-manager` subagent → run full plan sync-back (all completed tasks/steps across all `phase-XX-*.md`, not only current phase), then update `plan.md` status/progress
+  2. `docs-manager` subagent → update `./docs` if changes warrant
+  3. `TaskUpdate` → mark all Tasks complete after sync-back verification (skip if Task tools unavailable)
+  4. Ask user if they want to commit via `git-manager` subagent
+  5. Run `/ck-journal` to write a concise technical journal entry upon completion
+
+## Required Subagents (MANDATORY)
+
+| Phase | Subagent | Requirement |
+|-------|----------|-------------|
+| Research | `researcher` | Optional in fast/code |
+| Scout | `scout` | Optional in code |
+| Plan | `planner` | Optional in code |
+| UI Work | `ui-ux-designer` | If frontend work |
+| Testing | `tester`, `debugger` | **MUST** spawn |
+| Review | `code-reviewer` | **MUST** spawn |
+| Finalize | `project-manager`, `docs-manager`, `git-manager` | **MUST** spawn all 3 |
+
+**CRITICAL ENFORCEMENT:**
+- Steps 4, 5, 6 **MUST** use Task tool to spawn subagents
+- DO NOT implement testing, review, or finalization yourself - DELEGATE
+- If workflow ends with 0 Task tool calls, it is INCOMPLETE
+- Pattern: `Task(subagent_type="[type]", prompt="[task]", description="[brief]")`
 
 ## References
 
 - `references/intent-detection.md` - Detection rules and routing logic
 - `references/workflow-steps.md` - Detailed step definitions for all modes
 - `references/review-cycle.md` - Interactive and auto review processes
-- `references/agent-patterns.md` - Agent invocation patterns
+- `references/subagent-patterns.md` - Subagent invocation patterns

package/skills/cook/references/intent-detection.md

@@ -67,25 +67,25 @@ Detect multiple features from natural language:
 ## Examples
 
 ```
-"/cook implement user auth"
+"/ck-cook implement user auth"
 → Mode: interactive (default, stops at review gates)
 
-"/cook plans/260120-auth/phase-02-api.md"
+"/ck-cook plans/260120-auth/phase-02-api.md"
 → Mode: code (path detected, stops at review gates)
 
-"/cook quick fix for the login bug"
+"/ck-cook quick fix for the login bug"
 → Mode: fast ("quick" keyword, stops at review gates)
 
-"/cook implement auth, payments, notifications, shipping"
+"/ck-cook implement auth, payments, notifications, shipping"
 → Mode: parallel (4 features, stops at review gates)
 
-"/cook implement dashboard --fast"
+"/ck-cook implement dashboard --fast"
 → Mode: fast (explicit flag, stops at review gates)
 
-"/cook implement everything --auto"
+"/ck-cook implement everything --auto"
 → Mode: auto (NO STOPS, implements all phases continuously)
 
-"/cook implement dashboard trust me"
+"/ck-cook implement dashboard trust me"
 → Mode: auto ("trust me" keyword, NO STOPS)
 ```
 

package/skills/cook/references/review-cycle.md

@@ -24,7 +24,7 @@ LOOP:
      │  - [suggestion]                         │
      └─────────────────────────────────────────┘
 
-  3. Ask user directly (header: "Review & Approve") — then wait for response:
+  3. asking the user (header: "Review & Approve"):
      IF critical_count > 0:
        - "Fix critical issues" → fix, re-run tester, cycle++, LOOP
        - "Fix all issues" → fix all, re-run tester, cycle++, LOOP
@@ -37,7 +37,7 @@ LOOP:
 
   4. IF cycle >= 3 AND user selects fix:
      → "⚠ 3 review cycles completed. Final decision required."
-     → Ask user: "Approve with noted issues" / "Abort workflow" — wait for response
+     → asking the user: "Approve with noted issues" / "Abort workflow"
 ```
 
 ## Auto-Handling Cycle (for auto modes)

package/skills/cook/references/subagent-patterns.md

@@ -0,0 +1,75 @@
+# Subagent Patterns
+
+Standard patterns for spawning and using subagents in cook workflows.
+
+## Task Tool Pattern
+```
+Task(subagent_type="[type]", prompt="[task description]", description="[brief]")
+```
+
+## Research Phase
+```
+Task(subagent_type="researcher", prompt="Research [topic]. Report ≤150 lines.", description="Research [topic]")
+```
+- Use multiple researchers in parallel for different topics
+- Keep reports ≤150 lines with citations
+
+## Scout Phase
+```
+Task(subagent_type="scout", prompt="Find files related to [feature] in codebase", description="Scout [feature]")
+```
+- Use `/ck-scout ext` (preferred) or `/ck-scout` (fallback)
+
+## Planning Phase
+```
+Task(subagent_type="planner", prompt="Create implementation plan based on reports: [reports]. Save to [path]", description="Plan [feature]")
+```
+- Input: researcher and scout reports
+- Output: `plan.md` + `phase-XX-*.md` files
+
+## UI Implementation
+```
+Task(subagent_type="ui-ux-designer", prompt="Implement [feature] UI per ./docs/design-guidelines.md", description="UI [feature]")
+```
+- For frontend work
+- Follow design guidelines
+
+## Testing
+```
+Task(subagent_type="tester", prompt="Run test suite for plan phase [phase-name]", description="Test [phase]")
+```
+- Must achieve 100% pass rate
+
+## Debugging
+```
+Task(subagent_type="debugger", prompt="Analyze failures: [details]", description="Debug [issue]")
+```
+- Use when tests fail
+- Provides root cause analysis
+
+## Code Review
+```
+Task(subagent_type="code-reviewer", prompt="Review changes for [phase]. Check security, performance, YAGNI/KISS/DRY. Return score (X/10), critical, warnings, suggestions.", description="Review [phase]")
+```
+
+## Project Management
+```
+Task(subagent_type="project-manager", prompt="Run full sync-back in [plan-path]: reconcile completed tasks with all phase files, backfill stale completed checkboxes across all phases, update plan.md status/progress, and report unresolved mappings.", description="Update plan")
+```
+
+## Documentation
+```
+Task(subagent_type="docs-manager", prompt="Update docs for [phase]. Changed files: [list]", description="Update docs")
+```
+
+## Git Operations
+```
+Task(subagent_type="git-manager", prompt="Stage and commit changes with conventional commit message", description="Commit changes")
+```
+
+## Parallel Execution
+```
+Task(subagent_type="fullstack-developer", prompt="Implement [phase-file] with file ownership: [files]", description="Implement phase [N]")
+```
+- Launch multiple for parallel phases
+- Include file ownership boundaries

package/skills/cook/references/workflow-steps.md

@@ -2,12 +2,14 @@
 
 All modes share core steps with mode-specific variations.
 
+**Task Tool Fallback:** `TaskCreate`/`TaskUpdate`/`TaskGet`/`TaskList` are CLI-only — unavailable in VSCode extension. If they error, use `TodoWrite` for progress tracking. All workflow steps remain functional without Task tools.
+
 ## Step 0: Intent Detection & Setup
 
 1. Parse input with `intent-detection.md` rules
 2. Log detected mode: `✓ Step 0: Mode [X] - [reason]`
 3. If mode=code: detect plan path, set active plan
-4. Use TaskCreate to create workflow step tasks (with dependencies if complex)
+4. Use `TaskCreate` to create workflow step tasks (with dependencies if complex)
 
 **Output:** `✓ Step 0: Mode [interactive|auto|fast|parallel|no-test|code] - [detection reason]`
 
@@ -15,7 +17,7 @@ All modes share core steps with mode-specific variations.
 
 **Interactive/Auto:**
 - Spawn multiple `researcher` agents in parallel
-- Use `/scout:ext` or `scout` agent for codebase search
+- Use `/ck-scout ext` or `scout` agent for codebase search
 - Keep reports ≤150 lines
 
 **Parallel:**
@@ -25,7 +27,7 @@ All modes share core steps with mode-specific variations.
 
 ### [Review Gate 1] Post-Research (skip if auto mode)
 - Present research summary to user
-- Ask user: "Proceed to planning?" / "Request more research" / "Abort" — then wait for response
+- Use asking the user to ask: "Proceed to planning?" / "Request more research" / "Abort"
 - **Auto mode:** Skip this gate
 
 ## Step 2: Planning
@@ -35,11 +37,11 @@ All modes share core steps with mode-specific variations.
 - Create `plan.md` + `phase-XX-*.md` files
 
 **Fast:**
-- Use `/plan:fast` with scout results only
+- Use `/ck-plan --fast` with scout results only
 - Minimal planning, focus on action
 
 **Parallel:**
-- Use `/plan:parallel` for dependency graph + file ownership matrix
+- Use `/ck-plan --parallel` for dependency graph + file ownership matrix
 
 **Code:**
 - Skip - plan already exists
@@ -49,19 +51,32 @@ All modes share core steps with mode-specific variations.
 
 ### [Review Gate 2] Post-Plan (skip if auto mode)
 - Present plan overview with phases
-- Ask user: "Approve plan and start implementation?" / "Request revisions" / "Abort" — then wait for response
+- Use asking the user to ask: "Validate the plan or approve plan to start implementation?" - "Validate" / "Approve" / "Abort" / "Other" ("Request revisions")
+  - "Validate": run `/ck-plan validate` skill invocation
+  - "Approve": continue to implementation
+  - "Abort": stop the workflow
+  - "Other": revise the plan based on user's feedback
 - **Auto mode:** Skip this gate
 
 ## Step 3: Implementation
 
+**IMPORTANT:**
+1. `TaskList` first — check for existing tasks (hydrated by planning skill in same session)
+2. If tasks exist → pick them up, skip re-creation
+3. If no tasks → read plan phases, `TaskCreate` for each unchecked `[ ]` item with priority order and metadata (`phase`, `planDir`, `phaseFile`)
+4. Tasks can be blocked by other tasks via `addBlockedBy`
+
 **All modes:**
+- Use `TaskUpdate` to mark tasks as `in_progress` immediately.
 - Execute phase tasks sequentially (Step 3.1, 3.2, etc.)
 - Use `ui-ux-designer` for frontend
-- Use ImageMagick/FFmpeg CLI for image assets
+- Use `ai-multimodal` (if available) for image assets
 - Run type checking after each file
 
 **Parallel mode:**
+- Utilize all tools of Tasks: `TaskCreate`, `TaskUpdate`, `TaskGet` and `TaskList`
 - Launch multiple `fullstack-developer` agents
+- When agents pick up a task, use `TaskUpdate` to assign task to agent and mark tasks as `in_progress` immediately.
 - Respect file ownership boundaries
 - Wait for parallel group before next
 
@@ -69,28 +84,31 @@ All modes share core steps with mode-specific variations.
 
 ### [Review Gate 3] Post-Implementation (skip if auto mode)
 - Present implementation summary (files changed, key changes)
-- Ask user: "Proceed to testing?" / "Request implementation changes" / "Abort" — then wait for response
+- Use asking the user to ask: "Proceed to testing?" / "Request implementation changes" / "Abort"
 - **Auto mode:** Skip this gate
 
 ## Step 4: Testing (skip if no-test mode)
 
 **All modes (except no-test):**
 - Write tests: happy path, edge cases, errors
-- Use `tester` agent
-- If failures: `debugger` → fix → repeat
-- **Forbidden:** fake mocks, commented tests, changed assertions
+- **MUST** spawn `tester` subagent: `Task(subagent_type="tester", prompt="Run test suite", description="Run tests")`
+- If failures: **MUST** spawn `debugger` subagent → fix → repeat
+- **Forbidden:** fake mocks, commented tests, changed assertions, skipping subagent delegation
 
-**Output:** `✓ Step 4: Tests [X/X passed]`
+**Output:** `✓ Step 4: Tests [X/X passed] - tester subagent invoked`
 
 ### [Review Gate 4] Post-Testing (skip if auto mode)
 - Present test results summary
-- Ask user: "Proceed to code review?" / "Request test fixes" / "Abort" — then wait for response
+- Use asking the user to ask: "Proceed to code review?" / "Request test fixes" / "Abort"
 - **Auto mode:** Skip this gate
 
 ## Step 5: Code Review
 
+**All modes - MANDATORY subagent:**
+- **MUST** spawn `code-reviewer` subagent: `Task(subagent_type="code-reviewer", prompt="Review changes. Return score, critical issues, warnings.", description="Code review")`
+- **DO NOT** review code yourself - delegate to subagent
+
 **Interactive/Parallel/Code/No-test:**
-- Use `code-reviewer` agent
 - Interactive cycle (max 3): see `review-cycle.md`
 - Requires user approval
 
@@ -103,19 +121,47 @@ All modes share core steps with mode-specific variations.
 - Simplified review, no fix loop
 - User approves or aborts
 
-**Output:** `✓ Step 5: Review [score]/10 - [Approved|Auto-approved]`
+**Output:** `✓ Step 5: Review [score]/10 - [Approved|Auto-approved] - code-reviewer subagent invoked`
 
 ## Step 6: Finalize
 
-**All modes:**
-1. `project-manager` + `docs-manager` agents in parallel
-2. Onboarding check (API keys, env vars)
-3. Auto-commit via `git-manager` agent
+**All modes - MANDATORY subagents (NON-NEGOTIABLE):**
+1. **MUST** spawn these subagents in parallel:
+   - `Task(subagent_type="project-manager", prompt="Run full sync-back for [plan-path]: reconcile all completed Tasks with all phase files, backfill stale completed checkboxes across every phase, then update plan.md frontmatter/table progress. Do NOT only mark current phase.", description="Update plan")`
+   - `Task(subagent_type="docs-manager", prompt="Update docs for changes.", description="Update docs")`
+2. Project-manager sync-back MUST include:
+
+### Status Sync (Finalize)
+
+Use CLI commands for deterministic status updates:
+
+```bash
+# Mark completed phases
+ck plan check <phase-id>
+
+# Mark in-progress phases
+ck plan check <phase-id> --start
+
+# Revert if needed
+ck plan uncheck <phase-id>
+```
+
+**Fallback:** If `ck` is not available, edit plan.md directly —
+only change the Status column cell, preserve table structure.
+   - Sweep all `phase-XX-*.md` files in the plan directory.
+   - Mark every completed item `[ ] → [x]` based on completed tasks (including earlier phases finished before current phase).
+   - Update `plan.md` status/progress (`pending`/`in-progress`/`completed`) from actual checkbox state.
+   - Return unresolved mappings if any completed task cannot be matched to a phase file.
+3. Use `TaskUpdate` to mark Tasks complete after sync-back confirmation.
+4. Onboarding check (API keys, env vars)
+5. **MUST** spawn git subagent: `Task(subagent_type="git-manager", prompt="Stage and commit changes", description="Commit")`
+
+**CRITICAL:** Step 6 is INCOMPLETE without spawning all 3 subagents. DO NOT skip subagent delegation.
 
-**Auto mode:** Continue to next phase automatically
+**Auto mode:** Continue to next phase automatically, start from **Step 3**.
 **Others:** Ask user before next phase
 
-**Output:** `✓ Step 6: Finalized - Status updated - Committed`
+**Output:** `✓ Step 6: Finalized - 3 subagents invoked - Full-plan sync-back completed - Committed`
 
 ## Mode-Specific Flow Summary
 
@@ -135,6 +181,12 @@ code:        0 → skip → skip → 3 → [R] → 4 → [R] → 5(user) → 6
 ## Critical Rules
 
 - Never skip steps without mode justification
-- Use TaskUpdate to mark tasks complete immediately
-- One task in_progress at a time (enforce via TaskList check)
+- **MANDATORY SUBAGENT DELEGATION:** Steps 4, 5, 6 MUST spawn subagents via Task tool. DO NOT implement directly.
+  - Step 4: `tester` (and `debugger` if failures)
+  - Step 5: `code-reviewer`
+  - Step 6: `project-manager`, `docs-manager`, `git-manager`
+- Use `TaskCreate` to create Tasks for each unchecked item with priority order and dependencies (or `TodoWrite` if Task tools unavailable).
+- Use `TaskUpdate` to mark Tasks `in_progress` when picking up a task (skip if Task tools unavailable).
+- Use `TaskUpdate` to mark Tasks `complete` immediately after finalizing the task (skip if Task tools unavailable).
 - All step outputs follow format: `✓ Step [N]: [status] - [metrics]`
+- **VALIDATION:** If Task tool calls = 0 at end of workflow, the workflow is INCOMPLETE.

package/skills/databases/SKILL.md

@@ -1,6 +1,8 @@
 ---
 name: databases
-description: Design schemas, write queries for MongoDB, PostgreSQL, SQL Server. Use for database design, SQL/NoSQL queries, aggregation pipelines, indexes, migrations, replication, performance optimization, psql CLI, EF Core.
+description: Design schemas, write queries for MongoDB and PostgreSQL. Use for database design, SQL/NoSQL queries, aggregation pipelines, indexes, migrations, replication, performance optimization, psql CLI.
+license: MIT
+argument-hint: "[query or schema task]"
 ---
 
 # Databases Skill
@@ -74,38 +76,9 @@ python scripts/db_performance_check.py --db mongodb --threshold 100ms
 - Regular VACUUM and ANALYZE maintenance
 - Connection pooling (pgBouncer) for web apps
 
-## .NET / Entity Framework Core
-
-For .NET projects, use Entity Framework Core with PostgreSQL or SQL Server:
-
-```csharp
-// DbContext configuration
-public class AppDbContext : DbContext
-{
-    public DbSet<User> Users => Set<User>();
-    public DbSet<Post> Posts => Set<Post>();
-
-    protected override void OnConfiguring(DbContextOptionsBuilder options)
-        => options.UseNpgsql("Host=localhost;Database=mydb;Username=user;Password=pass");
-        // Or: options.UseSqlServer(connectionString);
-}
-
-// Migrations
-// dotnet ef migrations add InitialCreate
-// dotnet ef database update
-
-// Query with LINQ
-var activeUsers = await _context.Users
-    .Where(u => u.IsActive)
-    .Include(u => u.Posts)
-    .ToListAsync();
-```
-
 ## Resources
 
 - MongoDB: https://www.mongodb.com/docs/
 - PostgreSQL: https://www.postgresql.org/docs/
-- SQL Server: https://learn.microsoft.com/sql/
-- Entity Framework Core: https://learn.microsoft.com/ef/core/
 - MongoDB University: https://learn.mongodb.com/
 - PostgreSQL Tutorial: https://www.postgresqltutorial.com/

package/skills/databases/db-design.md

@@ -173,7 +173,7 @@ Before delivering final DDL:
 ## File Structure
 
 ```
-$HOME/.copilot/skills/databases/
+skills/databases/
 ├── SKILL.md                  # Skill description (entry + execution process + checklist)
 ├── db-design.md              # This file 
 ├── transactional.md          # OLTP design rules