konductor 0.7.3 → 0.10.0

package/agents/konductor-code-reviewer.json

@@ -0,0 +1,39 @@
+{
+    "name": "konductor-code-reviewer",
+    "description": "Reviews code changes after execution for correctness, security, and quality. Reports findings for the executor to fix.",
+    "tools": [
+        "read",
+        "write",
+        "shell",
+        "code"
+    ],
+    "allowedTools": [
+        "read",
+        "write",
+        "shell",
+        "code"
+    ],
+    "resources": [
+        "file://.konductor/requirements.md",
+        "file://.konductor/project.md",
+        "file://.konductor/phases/*/plans/*.md",
+        "file://.kiro/steering/**/*.md"
+    ],
+    "hooks": {
+        "preToolUse": [
+            {
+                "matcher": "*",
+                "command": "konductor hook",
+                "timeout_ms": 1000
+            }
+        ],
+        "postToolUse": [
+            {
+                "matcher": "*",
+                "command": "konductor hook",
+                "timeout_ms": 2000
+            }
+        ]
+    },
+    "prompt": "You are a code reviewer. Review all modified source files and evaluate against these criteria: (1) Correctness — does the code match what the plan and summary describe? (2) Error handling — are errors handled, not silently swallowed? (3) Security — no hardcoded secrets, no injection risks, no path traversal, proper input validation. (4) Duplication — is there copy-pasted logic that should be extracted into a shared function/module? (5) Performance — unnecessary allocations in hot paths, N+1 queries, unbounded loops, blocking calls in async code. (6) Dead code — no unused imports, unreachable branches, or commented-out blocks. (7) Consistency — does the code follow patterns already established in the codebase? (8) TODOs/FIXMEs — any left behind that should have been resolved? Run the project's test suite and linter. Do NOT fix any issues yourself — only report them with file, line, description, and severity (minor/significant). Write all findings to code-review.md."
+}

package/agents/konductor-codebase-mapper.json

@@ -14,19 +14,21 @@
         "code"
     ],
     "resources": [],
-    "hooks": [
-        {
-            "event": "PostToolUse",
-            "matcher": "write",
-            "command": "konductor hook",
-            "timeout_ms": 2000
-        },
-        {
-            "event": "PreToolUse",
-            "matcher": "shell",
-            "command": "konductor hook",
-            "timeout_ms": 1000
-        }
-    ],
+    "hooks": {
+        "preToolUse": [
+            {
+                "matcher": "*",
+                "command": "konductor hook",
+                "timeout_ms": 1000
+            }
+        ],
+        "postToolUse": [
+            {
+                "matcher": "*",
+                "command": "konductor hook",
+                "timeout_ms": 2000
+            }
+        ]
+    },
     "prompt": ""
 }

package/agents/konductor-design-reviewer.json

@@ -0,0 +1,40 @@
+{
+    "name": "konductor-design-reviewer",
+    "description": "Reviews phase design.md and per-plan Design sections for architectural soundness, feasibility, risk, security, cross-plan consistency, and requirement coverage. Writes structured feedback.",
+    "tools": [
+        "read",
+        "write",
+        "shell",
+        "code"
+    ],
+    "allowedTools": [
+        "read",
+        "write",
+        "shell",
+        "code"
+    ],
+    "resources": [
+        "file://.konductor/requirements.md",
+        "file://.konductor/roadmap.md",
+        "file://.konductor/project.md",
+        "file://.konductor/phases/*/plans/*.md",
+        "file://.kiro/steering/**/*.md"
+    ],
+    "hooks": {
+        "preToolUse": [
+            {
+                "matcher": "*",
+                "command": "konductor hook",
+                "timeout_ms": 1000
+            }
+        ],
+        "postToolUse": [
+            {
+                "matcher": "*",
+                "command": "konductor hook",
+                "timeout_ms": 2000
+            }
+        ]
+    },
+    "prompt": "You are a design reviewer. Evaluate the phase design.md and per-plan ## Design sections against these criteria: (1) Architectural soundness — do components and interactions make sense? (2) Feasibility — are proposed interfaces and approaches realistic given the codebase? (3) Security — are there hardcoded secrets, injection risks, missing input validation, or unsafe patterns? (4) Risk — missing error handling, dependency issues, integration gaps. (5) Cross-plan consistency — do shared interfaces match across dependent plans? (6) Requirement coverage — every REQ-XX for this phase is addressed. Write findings to review.md with a verdict (pass/revise/reject), issues with severity (critical/warning/info), and strengths."
+}

package/agents/konductor-discoverer.json

@@ -14,19 +14,21 @@
         "code"
     ],
     "resources": [],
-    "hooks": [
-        {
-            "event": "PostToolUse",
-            "matcher": "write",
-            "command": "konductor hook",
-            "timeout_ms": 2000
-        },
-        {
-            "event": "PreToolUse",
-            "matcher": "shell",
-            "command": "konductor hook",
-            "timeout_ms": 1000
-        }
-    ],
+    "hooks": {
+        "preToolUse": [
+            {
+                "matcher": "*",
+                "command": "konductor hook",
+                "timeout_ms": 1000
+            }
+        ],
+        "postToolUse": [
+            {
+                "matcher": "*",
+                "command": "konductor hook",
+                "timeout_ms": 2000
+            }
+        ]
+    },
     "prompt": ""
 }

package/agents/konductor-executor.json

@@ -19,19 +19,21 @@
         "file://.konductor/phases/*/plans/*.md",
         "file://.kiro/steering/**/*.md"
     ],
-    "hooks": [
-        {
-            "event": "PostToolUse",
-            "matcher": "write",
-            "command": "konductor hook",
-            "timeout_ms": 2000
-        },
-        {
-            "event": "PreToolUse",
-            "matcher": "shell",
-            "command": "konductor hook",
-            "timeout_ms": 1000
-        }
-    ],
+    "hooks": {
+        "preToolUse": [
+            {
+                "matcher": "*",
+                "command": "konductor hook",
+                "timeout_ms": 1000
+            }
+        ],
+        "postToolUse": [
+            {
+                "matcher": "*",
+                "command": "konductor hook",
+                "timeout_ms": 2000
+            }
+        ]
+    },
     "prompt": ""
 }

package/agents/konductor-plan-checker.json

@@ -17,19 +17,21 @@
         "file://.konductor/requirements.md",
         "file://.konductor/phases/*/plans/*.md"
     ],
-    "hooks": [
-        {
-            "event": "PostToolUse",
-            "matcher": "write",
-            "command": "konductor hook",
-            "timeout_ms": 2000
-        },
-        {
-            "event": "PreToolUse",
-            "matcher": "shell",
-            "command": "konductor hook",
-            "timeout_ms": 1000
-        }
-    ],
+    "hooks": {
+        "preToolUse": [
+            {
+                "matcher": "*",
+                "command": "konductor hook",
+                "timeout_ms": 1000
+            }
+        ],
+        "postToolUse": [
+            {
+                "matcher": "*",
+                "command": "konductor hook",
+                "timeout_ms": 2000
+            }
+        ]
+    },
     "prompt": ""
 }

package/agents/konductor-planner.json

@@ -19,19 +19,21 @@
         "file://.konductor/roadmap.md",
         "file://.kiro/steering/**/*.md"
     ],
-    "hooks": [
-        {
-            "event": "PostToolUse",
-            "matcher": "write",
-            "command": "konductor hook",
-            "timeout_ms": 2000
-        },
-        {
-            "event": "PreToolUse",
-            "matcher": "shell",
-            "command": "konductor hook",
-            "timeout_ms": 1000
-        }
-    ],
+    "hooks": {
+        "preToolUse": [
+            {
+                "matcher": "*",
+                "command": "konductor hook",
+                "timeout_ms": 1000
+            }
+        ],
+        "postToolUse": [
+            {
+                "matcher": "*",
+                "command": "konductor hook",
+                "timeout_ms": 2000
+            }
+        ]
+    },
     "prompt": ""
 }

package/agents/konductor-researcher.json

@@ -18,19 +18,21 @@
         "file://.konductor/requirements.md",
         "file://.kiro/steering/**/*.md"
     ],
-    "hooks": [
-        {
-            "event": "PostToolUse",
-            "matcher": "write",
-            "command": "konductor hook",
-            "timeout_ms": 2000
-        },
-        {
-            "event": "PreToolUse",
-            "matcher": "shell",
-            "command": "konductor hook",
-            "timeout_ms": 1000
-        }
-    ],
+    "hooks": {
+        "preToolUse": [
+            {
+                "matcher": "*",
+                "command": "konductor hook",
+                "timeout_ms": 1000
+            }
+        ],
+        "postToolUse": [
+            {
+                "matcher": "*",
+                "command": "konductor hook",
+                "timeout_ms": 2000
+            }
+        ]
+    },
     "prompt": ""
 }

package/agents/konductor-verifier.json

@@ -18,19 +18,21 @@
         "file://.konductor/phases/*/plans/*.md",
         "file://.kiro/steering/**/*.md"
     ],
-    "hooks": [
-        {
-            "event": "PostToolUse",
-            "matcher": "write",
-            "command": "konductor hook",
-            "timeout_ms": 2000
-        },
-        {
-            "event": "PreToolUse",
-            "matcher": "shell",
-            "command": "konductor hook",
-            "timeout_ms": 1000
-        }
-    ],
+    "hooks": {
+        "preToolUse": [
+            {
+                "matcher": "*",
+                "command": "konductor hook",
+                "timeout_ms": 1000
+            }
+        ],
+        "postToolUse": [
+            {
+                "matcher": "*",
+                "command": "konductor hook",
+                "timeout_ms": 2000
+            }
+        ]
+    },
     "prompt": ""
 }

package/agents/konductor.json

@@ -1,6 +1,7 @@
 {
     "name": "konductor",
     "description": "Spec-driven development orchestrator. Manages project initialization, phase planning, execution, verification, and shipping. Use @k-plan, @k-exec, @k-verify, @k-next, @k-status, or other prompts to trigger commands.",
+    "model": "claude-opus-4.6-1m",
     "tools": [
         "read",
         "write",
@@ -39,19 +40,21 @@
             ]
         }
     },
-    "hooks": [
-        {
-            "event": "PostToolUse",
-            "matcher": "write",
-            "command": "konductor hook",
-            "timeout_ms": 2000
-        },
-        {
-            "event": "PreToolUse",
-            "matcher": "shell",
-            "command": "konductor hook",
-            "timeout_ms": 1000
-        }
-    ],
+    "hooks": {
+        "preToolUse": [
+            {
+                "matcher": "*",
+                "command": "konductor hook",
+                "timeout_ms": 1000
+            }
+        ],
+        "postToolUse": [
+            {
+                "matcher": "*",
+                "command": "konductor hook",
+                "timeout_ms": 2000
+            }
+        ]
+    },
     "prompt": "Use the konductor MCP tools (state_init, state_get, state_transition, state_add_blocker, state_resolve_blocker, plans_list, status) for all state management instead of reading/writing state.toml directly."
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "konductor",
-  "version": "0.7.3",
+  "version": "0.10.0",
   "description": "Spec-driven development orchestrator for Kiro CLI — MCP server and hook processor",
   "bin": {
     "konductor": "bin/konductor"
@@ -10,7 +10,6 @@
     "scripts/",
     "agents/",
     "skills/",
-    "hooks/",
     "README.md"
   ],
   "scripts": {

package/scripts/postinstall.js

@@ -72,7 +72,7 @@ async function main() {
   fs.chmodSync(dest, 0o755);
   console.log("konductor binary installed.");
 
-  // Install agents, skills, and hooks to ~/.kiro/
+  // Install agents and skills to ~/.kiro/
   installKiroAssets();
 }
 
@@ -99,7 +99,6 @@ function installKiroAssets() {
   const assets = [
     { src: "agents", dest: "agents" },
     { src: "skills", dest: "skills" },
-    { src: "hooks", dest: "hooks" },
   ];
 
   for (const { src, dest } of assets) {

package/skills/konductor-exec/SKILL.md

@@ -110,13 +110,33 @@ If an executor fails (crashes, times out, or reports errors):
 
 After each wave completes, track progress (completed plans count and percentage) for reporting.
 
-## Step 6: Set Executed State
+## Step 6: Code Review (if enabled)
 
-After all waves complete, call `state_transition` with `step = "executed"` to advance the pipeline.
+If `config.toml` `features.code_review = true`:
+
+Spawn a **konductor-code-reviewer** agent. Provide it with:
+- `.konductor/.tracking/modified-files.log` (list of changed files)
+- All `*-summary.md` files from `.konductor/phases/{phase}/plans/`
+- The phase name and plan files for context
+- Instructions: review all modified source files, run tests and linting, do NOT fix any issues — only report them with file, line, description, and severity (minor/significant). Write findings to `.konductor/phases/{phase}/code-review.md`.
+
+Wait for the reviewer to complete. Read `code-review.md`.
+
+**If the review reports issues:**
+1. Spawn a **konductor-executor** agent with the issues from `code-review.md` as context. Instruct it to fix all reported issues and commit with `fix({phase}): code review fixes`.
+2. Re-run the **konductor-code-reviewer** to verify the fixes.
+3. Maximum 3 review-fix iterations. If issues remain after 3 iterations, call `state_add_blocker` with a summary of remaining issues and report to user.
+
+**If no issues remain:** Proceed to Step 7.
+
+## Step 7: Set Executed State
+
+After code review completes (with no blocking issues), call `state_transition` with `step = "executed"` to advance the pipeline.
 
 Tell the user:
 - Total plans executed
 - Plans succeeded vs. failed (if any)
+- Code review findings (issues fixed, warnings reported)
 - Next step suggestion: "Say 'next' to verify the phase."
 
 If any plans failed, list them and suggest:

package/skills/konductor-next/SKILL.md

@@ -50,7 +50,7 @@ Then run the **Planning Pipeline**:
    - requirements.md
    - roadmap.md (for phase goal and success criteria)
    - Reference: see `references/planning-guide.md` in the konductor-plan skill
-   The planner will write plan files to `.konductor/phases/{phase}/plans/`.
+   The planner will first write `.konductor/phases/{phase}/design.md` with the phase-level architecture, then write plan files with `## Design` sections to `.konductor/phases/{phase}/plans/`.
    Wait for completion.
 
 3. **Check Plans** (if `config.toml` `features.plan_checker = true`):
@@ -59,7 +59,18 @@ Then run the **Planning Pipeline**:
    - requirements.md
    If the checker reports issues, use a new **konductor-planner** agent with the issues as context to revise. Then re-check. Maximum 3 iterations.
 
-4. **Update State**:
+4. **Design Review** (if `config.toml` `features.design_review = true`):
+   Use the **konductor-design-reviewer** agent to review the design. Provide it with:
+   - `.konductor/phases/{phase}/design.md`
+   - All plan files in `.konductor/phases/{phase}/plans/`
+   - requirements.md, roadmap.md, project.md
+   The reviewer writes `.konductor/phases/{phase}/review.md` with a verdict (pass/revise/reject) and issues.
+   If verdict is "revise": spawn a new **konductor-planner** with the review feedback to revise design.md and affected plans, then re-run the reviewer. Maximum 2 iterations.
+   Present the review summary to the user. Ask: "Approve plans for execution? (approve / reject)".
+   On approve: proceed to step 5.
+   On reject: stop. Do not advance state.
+
+5. **Update State**:
    Write `.konductor/.results/plan-{phase}.toml`:
    ```toml
    step = "plan"
@@ -96,8 +107,11 @@ The phase is ready for execution. Run the **Execution Pipeline**:
    After each wave completes, track progress.
 
 6. Write `.konductor/.results/execute-{phase}-plan-{n}.toml` for each completed plan.
-7. Call `state_transition` with `step = "executed"`.
-8. Tell the user: "Phase {phase} executed. N plans completed. Say 'next' to verify."
+7. **Code Review** (if `config.toml` `features.code_review = true`):
+   Spawn **konductor-code-reviewer** agent with: `.konductor/.tracking/modified-files.log`, all `*-summary.md` files from plans directory, phase name. The reviewer writes `.konductor/phases/{phase}/code-review.md`.
+   If issues found: spawn a **konductor-executor** agent with the issues to fix them, then re-run the reviewer. Maximum 3 review-fix iterations. If still unresolved, call `state_add_blocker` and report to user.
+8. Call `state_transition` with `step = "executed"`.
+9. Tell the user: "Phase {phase} executed. N plans completed. Say 'next' to verify."
 
 ### Case: `step = "executing"`
 

package/skills/konductor-plan/SKILL.md

@@ -10,7 +10,7 @@ You are the Konductor orchestrator. Plan a phase by researching the ecosystem, c
 ## Critical Rules
 
 1. **Only YOU manage state transitions** — use the MCP tools (`state_get`, `state_transition`, `state_add_blocker`) instead of writing `state.toml` directly. Subagents write their own output files.
-2. **Read `config.toml` first** — respect feature flags (research, plan_checker).
+2. **Read `config.toml` first** — respect feature flags (research, plan_checker, design_review).
 3. **Report errors, don't retry crashes** — if a subagent fails, set status to "blocked".
 4. **Accept a phase argument** — the user may say "plan phase 01" or "plan phase 01-auth-system". Resolve short form by scanning `.konductor/phases/` directories.
 
@@ -44,9 +44,9 @@ Use the **konductor-planner** agent to decompose the phase into execution plans.
 - `.konductor/requirements.md`
 - `.konductor/roadmap.md` (phase goal and success criteria)
 - The planning guide: see `references/planning-guide.md`
-- Instructions: create plan files in `.konductor/phases/{phase}/plans/` using TOML frontmatter format
+- Instructions: first write `.konductor/phases/{phase}/design.md` with the phase-level architecture (see planning guide "Phase-Level Design Document" section), then create plan files in `.konductor/phases/{phase}/plans/` using TOML frontmatter format with `## Design` sections in each plan
 
-Wait for the planner to complete. Verify at least one plan file was created.
+Wait for the planner to complete. Verify `design.md` was created and at least one plan file exists.
 
 ## Step 4: Validate Plans (if enabled)
 
@@ -62,7 +62,63 @@ If the checker reports issues that it could not fix:
 - Re-run the **konductor-plan-checker**
 - Maximum 3 iterations. If still unresolved, report to user.
 
-## Step 5: Update State
+## Step 5: Design Review (if enabled)
+
+If `config.toml` `features.design_review = true`:
+
+Use the **konductor-design-reviewer** agent to review the technical design. Provide it with:
+- `.konductor/phases/{phase}/design.md`
+- All plan files in `.konductor/phases/{phase}/plans/`
+- `.konductor/requirements.md`
+- `.konductor/roadmap.md` (phase goal and success criteria)
+- `.konductor/project.md` (tech stack and constraints)
+- Instructions: analyze the phase design and per-plan Design sections, then write a structured review to `.konductor/phases/{phase}/review.md`
+
+**Review criteria the agent must evaluate:**
+1. Architectural soundness of design.md — do the components and interactions make sense?
+2. Feasibility of per-plan Design sections — are the proposed interfaces and approaches realistic?
+3. Cross-plan consistency — do shared interfaces match across plans that depend on each other?
+4. Requirement coverage — every REQ-XX for this phase is addressed
+5. Risk identification — missing error handling, security concerns, dependency issues
+
+**Review output format** (written to `.konductor/phases/{phase}/review.md`):
+```markdown
+# Design Review: Phase {phase}
+
+## Summary
+{one paragraph overall assessment}
+
+## Verdict: {pass | revise | reject}
+
+## Issues
+
+### Issue 1: {title}
+- **Severity:** critical | warning | info
+- **Affected plan:** {plan number or "design.md"}
+- **Description:** {what's wrong}
+- **Suggestion:** {how to fix}
+
+## Strengths
+{what the design does well}
+```
+
+Wait for the reviewer to complete. Verify `review.md` was created.
+
+**If verdict is "pass":** Proceed to Step 6.
+
+**If verdict is "revise"** (has critical or warning issues):
+1. Spawn a new **konductor-planner** agent with the review feedback as additional context
+2. Instruct it to revise `design.md` and the affected plans in-place
+3. Re-run the **konductor-design-reviewer**
+4. Maximum 2 review-revise iterations. If still "revise" after 2 iterations, proceed to user approval with warnings noted.
+
+**Present the review summary to the user.** Ask:
+> "Approve plans for execution? (approve / reject)"
+
+- **On approve:** Proceed to Step 6.
+- **On reject:** Stop. Do not advance state. Tell the user: "Plans not approved. Edit the plans in `.konductor/phases/{phase}/plans/` or re-run planning."
+
+## Step 6: Update State
 
 Write `.konductor/.results/plan-{phase}.toml`:
 ```toml

package/skills/konductor-plan/references/planning-guide.md

@@ -76,6 +76,16 @@ Each plan is a markdown file with TOML frontmatter and a structured body.
 - `must_haves.artifacts`: Files that must exist
 - `must_haves.key_links`: Wiring checks (A imports B, C calls D)
 
+**Body sections (in order):**
+- `## Goal`: What this plan delivers
+- `## Design`: Technical design for this plan's implementation
+  - `### Approach`: Why this approach, what alternatives were considered
+  - `### Key Interfaces`: Function signatures, type definitions, API contracts introduced or modified by this plan
+  - `### Error Handling`: How errors are handled within this plan's scope
+  - `### Trade-offs`: What was traded off and why
+- `## Dependencies` (optional): Interface context from plans this one depends on
+- `## Tasks`: Ordered list of implementation tasks
+
 **Complete example:**
 ```markdown
 +++
@@ -99,6 +109,33 @@ key_links = ["User model imported by auth routes", "bcrypt used in user.rs"]
 ## Goal
 Create the User data model and database schema to support user registration.
 
+## Design
+
+### Approach
+Use a single User struct with private password_hash field. Bcrypt for hashing (industry standard, built-in salt). Migration creates the users table directly — no ORM migration framework needed at this stage.
+
+### Key Interfaces
+```rust
+pub struct User {
+    pub id: Uuid,
+    pub email: String,
+    password_hash: String,
+    pub created_at: DateTime<Utc>,
+}
+
+impl User {
+    pub fn new(email: String, password: String) -> Result<Self, AuthError>;
+    pub fn verify_password(&self, password: &str) -> bool;
+}
+```
+
+### Error Handling
+`User::new` returns `AuthError::WeakPassword` if password doesn't meet requirements, `AuthError::HashError` if bcrypt fails. Callers handle these via the Result type.
+
+### Trade-offs
+- Bcrypt over argon2: simpler dependency, sufficient for this use case, slightly slower but acceptable
+- No email uniqueness enforcement at struct level — handled by DB unique constraint
+
 ## Tasks
 
 ### Task 1: Create User struct
@@ -130,6 +167,44 @@ Create the User data model and database schema to support user registration.
 - **done:** Registration route can create User instances
 ```
 
+## Phase-Level Design Document
+
+Before writing individual plans, the planner must produce `.konductor/phases/{phase}/design.md`. This document captures the overall technical design for the phase, giving reviewers and executors a holistic view.
+
+**Contents:**
+1. **Overview** — one paragraph summarizing the architectural approach for this phase
+2. **Components** — which modules, files, or services are involved and their responsibilities
+3. **Interactions** — how components communicate (function calls, API requests, event flows)
+4. **Key Decisions** — architectural choices that span multiple plans, with rationale
+5. **Shared Interfaces** — type definitions, function signatures, or API contracts used across multiple plans
+
+**Template:**
+```markdown
+# Design: Phase {phase} — {name}
+
+## Overview
+{One paragraph: what is being built and the high-level approach}
+
+## Components
+- **{component}**: {responsibility}
+- **{component}**: {responsibility}
+
+## Interactions
+{Describe how components interact — which calls which, data flow}
+
+## Key Decisions
+
+### {Decision title}
+**Choice:** {what was decided}
+**Rationale:** {why}
+**Alternatives considered:** {what else was evaluated}
+
+## Shared Interfaces
+{Type definitions, function signatures, or API contracts referenced by multiple plans}
+```
+
+Individual plan `## Design` sections should reference this document for shared context rather than duplicating it. For example: "See design.md Key Decisions for the choice of bcrypt over argon2."
+
 ## Goal-Backward Methodology
 
 Work backward from the phase goal to derive concrete requirements.
@@ -253,7 +328,9 @@ Use this interface in Task 2 when implementing the login handler.
 
 Before finalizing plans, verify:
 
+- [ ] Phase-level `design.md` exists with overview, components, interactions, key decisions, and shared interfaces
 - [ ] Every plan has valid TOML frontmatter
+- [ ] Every plan has a `## Design` section with Approach, Key Interfaces, Error Handling, and Trade-offs
 - [ ] Wave numbers form a valid DAG (no cycles)
 - [ ] Each plan has 2-5 tasks
 - [ ] Each task has files, action, verify, and done

package/skills/konductor-ship/SKILL.md

@@ -60,23 +60,37 @@ Read `.konductor/.results/verify-integration.toml`.
 - Tell the user: "Integration issues found. Fix these before shipping: {list of issues}. You can use 'exec' to re-run specific plans or fix manually."
 - Stop here
 
-## Step 5: Create Release Tag
+## Step 5: Create Release Branch and PR
 
 Read `.konductor/project.md` to extract:
 - Project name
 - Version (if specified, or use "v1.0.0" as default)
 
-Create a git tag:
+Create a feature branch, rebase onto the default branch, and push a PR:
+
 ```bash
-git tag -a {version} -m "Release {version}: {project name} complete
+# Ensure we're up to date
+git fetch origin
+
+# Determine default branch
+DEFAULT_BRANCH=$(git remote show origin | grep 'HEAD branch' | awk '{print $NF}')
 
-All {phases_total} phases implemented and verified.
+# Create release branch
+git checkout -b release/{version}
 
-Generated with Konductor orchestrator"
+# Rebase onto default branch
+git rebase origin/$DEFAULT_BRANCH
+
+# Push and create PR
+git push -u origin release/{version}
 ```
 
+Create a pull request targeting the default branch with:
+- **Title:** `release: {version} — {project name}`
+- **Body:** Summary of all phases completed, verification status, and milestone info
+
 Tell the user:
-> "Created git tag: {version}"
+> "Created release branch and PR for {version}. Review and merge to ship."
 
 ## Step 6: Archive Project State
 
@@ -133,11 +147,11 @@ Tell the user:
 - {phases_total} phases completed
 - {total_agent_sessions} agent sessions
 - Verified: All integration checks passed
-- Tagged: {version}
+- Release PR: {pr_url}
 - Archived: .konductor/milestones/{version}/
 
 ## Next Steps
-- Push the git tag: `git push origin {version}`
+- Review and merge the release PR
 - Review the milestone summary: `.konductor/milestones/{version}/summary.md`
 - Consider deploying your project
 
@@ -152,9 +166,9 @@ If phases are incomplete, do NOT proceed with shipping. Report the gap and stop.
 **Verification failures:**
 If the verifier finds issues, do NOT create tags or archives. Report issues and stop.
 
-**Git tag already exists:**
-If the tag already exists, warn the user:
-> "Tag {version} already exists. Use a different version or delete the existing tag first."
+**Release branch already exists:**
+If the branch `release/{version}` already exists, warn the user:
+> "Branch release/{version} already exists. Use a different version or delete the existing branch first."
 
 Then stop.
 

package/hooks/konductor-hooks.json

@@ -1,16 +0,0 @@
-{
-    "hooks": [
-        {
-            "event": "PostToolUse",
-            "matcher": "write",
-            "command": "konductor hook",
-            "timeout_ms": 2000
-        },
-        {
-            "event": "PreToolUse",
-            "matcher": "shell",
-            "command": "konductor hook",
-            "timeout_ms": 1000
-        }
-    ]
-}