konductor 0.5.0 → 0.7.0

package/skills/konductor-ship/SKILL.md

@@ -0,0 +1,165 @@
+---
+name: konductor-ship
+description: Ship and finalize the project. Use when the user says ship, release, finalize, we're done, ready to ship, or complete project.
+---
+
+# Konductor Ship — Project Finalization and Release
+
+You are the Konductor orchestrator. Finalize and ship the project after all phases are complete.
+
+## Step 1: Read Project State
+
+Call the `state_get` MCP tool to verify project readiness:
+- Check `current.phase` — should be the last phase
+- Check `current.step` — should be "complete"
+- Check `progress.phases_complete` — should equal `phases_total`
+
+If the project is not ready to ship, proceed to Step 2 to report the gap.
+
+## Step 2: Verify All Phases Complete
+
+Read `.konductor/roadmap.md` to get the full list of phases.
+
+For each phase:
+1. Check if `.konductor/phases/{phase}/` directory exists
+2. Check if summary files exist for all plans
+3. Verify that the phase has `step = "complete"` in state history
+
+If any phases are incomplete:
+- List which phases are not complete
+- Show their current step
+- Tell the user: "Cannot ship yet. Complete these phases first: {list}. Say 'status' to see current progress."
+- Stop here
+
+## Step 3: Cross-Phase Integration Verification
+
+Spawn the **konductor-verifier** agent with instructions to perform a cross-phase integration check:
+- Verify that outputs from earlier phases integrate correctly with later phases
+- Check that API contracts are honored
+- Test critical user flows that span multiple phases
+- Look for integration gaps or inconsistencies between phase boundaries
+- Reference: see `references/verification.md` for verification patterns
+
+Provide the verifier with:
+- All phase directories: `.konductor/phases/*/`
+- All summary files from each phase
+- The project roadmap for context
+
+Wait for the verifier to complete and write its results to `.konductor/.results/verify-integration.toml`.
+
+## Step 4: Check Verification Results
+
+Read `.konductor/.results/verify-integration.toml`.
+
+**If status = "ok":**
+- Proceed to Step 5 (finalization)
+
+**If status = "error" or issues found:**
+- Display the issues to the user
+- List affected phases and specific problems
+- 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
+
+Read `.konductor/project.md` to extract:
+- Project name
+- Version (if specified, or use "v1.0.0" as default)
+
+Create a git tag:
+```bash
+git tag -a {version} -m "Release {version}: {project name} complete
+
+All {phases_total} phases implemented and verified.
+
+Generated with Konductor orchestrator"
+```
+
+Tell the user:
+> "Created git tag: {version}"
+
+## Step 6: Archive Project State
+
+Create an archive of the current state for historical reference:
+
+```bash
+mkdir -p .konductor/milestones/{version}
+cp -r .konductor/phases .konductor/milestones/{version}/
+cp .konductor/state.toml .konductor/milestones/{version}/
+cp .konductor/roadmap.md .konductor/milestones/{version}/
+cp .konductor/project.md .konductor/milestones/{version}/
+```
+
+Write a milestone summary file at `.konductor/milestones/{version}/summary.md`:
+
+```markdown
+# {project name} — {version} Release
+
+Released: {current date}
+
+## Summary
+{brief project description from project.md}
+
+## Phases Completed
+{for each phase}
+- Phase {number}: {name} — {goal}
+{/for}
+
+## Metrics
+- Total phases: {phases_total}
+- Total agent sessions: {total_agent_sessions}
+- Project duration: {initialized date} to {current date}
+
+## Verification
+Cross-phase integration verified on {current date}.
+
+All phase outputs integrated successfully.
+```
+
+## Step 7: Update State to Shipped
+
+Call `state_transition` with `step = "shipped"` to finalize the project state.
+
+## Step 8: Report Success
+
+Tell the user:
+
+```
+# Project Shipped! 🎉
+
+{project name} {version} has been finalized.
+
+## Summary
+- {phases_total} phases completed
+- {total_agent_sessions} agent sessions
+- Verified: All integration checks passed
+- Tagged: {version}
+- Archived: .konductor/milestones/{version}/
+
+## Next Steps
+- Push the git tag: `git push origin {version}`
+- Review the milestone summary: `.konductor/milestones/{version}/summary.md`
+- Consider deploying your project
+
+Great work!
+```
+
+## Error Handling
+
+**Incomplete phases:**
+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."
+
+Then stop.
+
+**Missing roadmap or state:**
+If critical files are missing:
+1. Report which files are missing
+2. Suggest running diagnostic: "Say 'status' to check project state."
+3. Stop

package/skills/konductor-status/SKILL.md

@@ -0,0 +1,109 @@
+---
+name: konductor-status
+description: Display project status and progress. Use when the user says status, progress, where are we, show state, what's happening, or current status.
+---
+
+# Konductor Status — Project Status Display
+
+You are the Konductor orchestrator. Display the current status and progress of the project.
+
+## Step 1: Get Project Status
+
+Call the `status` MCP tool. This returns a structured JSON report with:
+- `project` — project name
+- `current_phase`, `current_step`, `status`
+- `phases_total`, `phases_complete`
+- `current_phase_plans`, `current_phase_plans_complete`
+- `active_blockers` count and `blockers` list
+- `last_activity`, `total_agent_sessions`
+- `next_suggestion`
+
+If the tool returns a `STATE_NOT_FOUND` error, tell the user:
+> "No Konductor project found. Run 'init' to initialize a project."
+
+Then stop.
+
+## Step 2: Parse Phase Status
+
+Read `.konductor/roadmap.md` to extract all phase numbers and names.
+
+Using the `current_phase` from the status report:
+1. If phase number < current phase number: status = "complete" (✓)
+2. If phase number = current phase number: status = "active" (○)
+3. If phase number > current phase number: status = "pending" (·)
+
+## Step 3: Read Recent Activity
+
+From `.konductor/.results/`, scan result files (most recent 5):
+- Look for files like `execute-{phase}-plan-{n}.toml`, `verify-{phase}.toml`, etc.
+- Extract timestamps and actions
+
+Use the `last_activity` and `total_agent_sessions` from the status report.
+
+## Step 4: Check for Decisions
+
+For the current phase, check if `.konductor/phases/{phase}/context.md` exists.
+- If it exists, read the decisions section
+- Extract recent decisions (last 2-3)
+
+## Step 5: Display Formatted Output
+
+Present a structured status report:
+
+```
+# Konductor Status
+
+## Phases
+{for each phase}
+{status_icon} Phase {number}: {name}
+{/for}
+
+## Current Position
+Phase: {current_phase_number} — {current_phase_name}
+Step: {current_step}
+
+## Progress
+{phases_complete} / {phases_total} phases complete ({percentage}%)
+{if active phase has plans: current_phase_plans_complete / current_phase_plans plans complete}
+
+## Metrics
+Total agent sessions: {total_agent_sessions}
+Last activity: {last_activity_relative} ({last_activity_absolute})
+
+{if blockers exist}
+## Blockers
+{list of blockers with phase and plan numbers}
+{/if}
+
+{if recent decisions exist}
+## Recent Decisions
+{list of recent decisions from context.md}
+{/if}
+
+## Next Steps
+{suggest what the user should do next based on current step}
+```
+
+**Status icons:**
+- ✓ = complete
+- ○ = active/in progress
+- · = pending
+
+**Next step suggestions by current step:**
+- `initialized` → "Say 'next' to start planning, or 'discuss phase {n}' to set preferences first."
+- `discussed` → "Say 'next' to begin planning phase {n}."
+- `planned` → "Say 'exec' to execute the plans."
+- `executing` → "Execution in progress. Wait for completion or check logs."
+- `executed` → "Say 'next' to verify the phase."
+- `verified` → "Say 'next' to mark phase complete and advance."
+- `complete` → "Phase {n} complete. Say 'next' to move to phase {n+1}."
+
+## Error Handling
+
+**Missing state files:**
+If the `status` tool returns an error:
+1. Report the error
+2. Suggest running `init` to reinitialize (warn about overwriting)
+
+**Empty results directory:**
+If `.konductor/.results/` is empty, that's normal for newly initialized projects — simply report no activity yet.

package/skills/konductor-verify/SKILL.md

@@ -0,0 +1,116 @@
+---
+name: konductor-verify
+description: Verify a phase after execution to validate that goals were achieved. Use when the user says verify phase, verify, check phase, validate phase, or check results.
+---
+
+# Konductor Verify — Phase Verification Pipeline
+
+You are the Konductor orchestrator. Verify a phase after execution to validate that the phase goals were actually achieved, not just that files were created.
+
+## 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 and settings.
+3. **Report errors, don't retry crashes** — if the verifier fails, set status to "blocked".
+4. **Use the 3-level verification framework** — Exists, Substantive, Wired (see references/verification-patterns.md).
+
+## Step 1: Read State and Validate Phase
+
+Call the `state_get` MCP tool to read current state, and read `.konductor/config.toml` for verification settings.
+
+Validate that `[current].step` is `"executed"`.
+
+If the phase is not in the executed state, tell the user:
+> "Phase {phase} has not been executed yet. Current step: {step}. Run 'exec phase {phase}' first."
+Then stop.
+
+## Step 2: Spawn Verifier Agent
+
+Use the **konductor-verifier** agent to perform 3-level verification (Exists, Substantive, Wired).
+
+Provide the verifier with:
+- All `*-summary.md` files from `.konductor/phases/{phase}/plans/` — these contain what was actually implemented
+- `.konductor/requirements.md` — the original requirements
+- `.konductor/roadmap.md` — phase goals and success criteria
+- All plan files from `.konductor/phases/{phase}/plans/` — to extract `must_haves` from frontmatter
+- Reference to `references/verification-patterns.md` — the 3-level verification framework
+- Instructions:
+  - Verify each plan's must_haves (from plan frontmatter) or derive from phase success criteria
+  - Check Level 1 (Exists): Do the artifacts exist?
+  - Check Level 2 (Substantive): Are they real implementations or stubs?
+  - Check Level 3 (Wired): Are they integrated with the system?
+  - Identify any gaps or incomplete implementations
+  - Write verification report to `.konductor/phases/{phase}/verification.md`
+
+Wait for the verifier to complete. Verify that `verification.md` was created.
+
+## Step 3: Read Verification Report
+
+Read `.konductor/phases/{phase}/verification.md`.
+
+Extract:
+- Overall status: `ok` or `issues-found`
+- Number of issues/gaps found
+- List of gaps (if any)
+
+Parse the verification report to determine:
+- Did all must_haves pass Level 1 (Exists)?
+- Did all must_haves pass Level 2 (Substantive)?
+- Did all must_haves pass Level 3 (Wired)?
+- Are there any failed truths or incomplete integrations?
+
+**Status determination:**
+- `ok`: All levels passed, no gaps
+- `issues-found`: One or more levels failed, or gaps identified
+
+## Step 4: Write Result File
+
+Write `.konductor/.results/verify-{phase}.toml`:
+
+```toml
+step = "verify"
+phase = "{phase}"
+status = "{ok or issues-found}"
+timestamp = {current ISO timestamp}
+issues_count = {number of gaps/issues}
+gaps = [
+  {list of gap descriptions}
+]
+```
+
+## Step 5a: If Status is OK
+
+The phase is complete. Update state using MCP tools:
+
+1. Call `state_transition` with `step = "complete"` to advance the pipeline
+2. The tool automatically handles status and timestamp updates
+
+Tell the user:
+- Phase {phase} verification passed
+- All must_haves are implemented and wired
+- Next phase: {next_phase}
+- Suggest: "Say 'next' to continue, or 'plan phase {next_phase}' to start planning."
+
+## Step 5b: If Status is Issues-Found
+
+The phase has gaps. Keep current step as "executed" (do NOT advance).
+
+Tell the user:
+- Phase {phase} verification found {N} issues
+- List the gaps clearly (use the gap list from verification.md)
+- Suggest: "Run 'plan phase {phase}' to create gap-closure plans, or manually fix the issues and re-run verification."
+
+Call `state_add_blocker` MCP tool with the phase and reason: "Verification found {N} issues. See verification.md for details."
+
+## Error Handling
+
+If the verifier agent fails:
+1. Write `.konductor/.results/verify-{phase}.toml` with `status = "error"` and error details
+2. Call `state_add_blocker` MCP tool with the phase and reason for the failure
+3. Report failure to user with actionable context
+4. Do NOT retry crashed subagents
+
+If `verification.md` is malformed or cannot be parsed:
+1. Report the parsing error
+2. Do not attempt to fix it automatically
+3. Suggest manual review of the verification report