@hanhnd/agent-kit 1.0.1 → 1.0.5

package/README.md

@@ -12,7 +12,7 @@
 | `/ak:plan [file or idea]`        | Create an implementation blueprint                                 |
 | `/ak:code [file or task]`        | Implement from a plan                                              |
 | `/ak:review-pr [PR URL]`         | Review a pull request                                              |
-| `/ak:review-changes`             | Review uncommitted local changes                                   |
+| `/ak:review`                     | Review uncommitted local changes                                   |
 | `/ak:ticket [ID]`                | Fetch a Jira ticket and plan from it                               |
 | `/ak:git`                        | Git commit, branch, and PR workflow                                |
 | `/ak:init`                       | Create the project overview file                                   |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hanhnd/agent-kit",
-  "version": "1.0.1",
+  "version": "1.0.5",
   "description": "Super Engineer - Team of AI Agents for software development (Claude Code Plugin)",
   "type": "module",
   "main": "dist/kit-server.js",
@@ -13,6 +13,10 @@
   "publishConfig": {
     "access": "public"
   },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hanh-nd/agent-kit.git"
+  },
   "scripts": {
     "prepublishOnly": "npm run build",
     "build": "tsc && npm run bundle",

package/dist/tools/gemini.d.ts

@@ -1,9 +0,0 @@
-/**
- * Agent Delegation Tools - Invoke external agent CLIs (Gemini, Claude)
- * Supports handoff file injection and automatic fallback
- */
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-/**
- * Register agent delegation tools with MCP server
- */
-export declare function registerGeminiTools(server: McpServer): void;

package/dist/tools/gemini.js

@@ -1,111 +0,0 @@
-/**
- * Agent Delegation Tools - Invoke external agent CLIs (Gemini, Claude)
- * Supports handoff file injection and automatic fallback
- */
-import { execFileSync } from 'child_process';
-import * as fs from 'fs';
-import * as path from 'path';
-import { z } from 'zod';
-import { getWorkspaceRoot } from '../utils.js';
-import { commandExists, validatePath } from './security.js';
-// Configurable timeout via environment variable (default: 5 minutes)
-const AGENT_TIMEOUT = parseInt(process.env.KIT_AGENT_TIMEOUT || '300000', 10);
-/**
- * Register agent delegation tools with MCP server
- */
-export function registerGeminiTools(server) {
-    // ═══════════════════════════════════════════════════════════════
-    // TOOL: TRIGGER AGENT
-    // Delegates a task to an external agent CLI (gemini or claude).
-    // Auto-detects if task is a file path and reads it as context.
-    // Falls back to the alternate agent if requested one is missing.
-    // ═══════════════════════════════════════════════════════════════
-    server.tool('kit_trigger_agent', 'Delegate a task to an external agent CLI (gemini or claude). The task can be a direct message or a path to a handoff file (.agent-kit/handoffs/plans/plan-xyz.md). Falls back to the other agent CLI if the requested one is not installed.', {
-        agent: z.enum(['gemini', 'claude']).describe('The agent CLI to invoke: "gemini" or "claude"'),
-        task: z
-            .string()
-            .describe('Task message or path to a handoff file (e.g., ".agent-kit/handoffs/plans/plan-xyz.md")'),
-    }, async ({ agent, task }) => {
-        try {
-            const workspaceRoot = getWorkspaceRoot();
-            // Detect if task is a file path — resolve and read if it exists
-            let prompt = task;
-            const resolvedTask = path.resolve(workspaceRoot, task);
-            if (fs.existsSync(resolvedTask) && fs.statSync(resolvedTask).isFile()) {
-                try {
-                    validatePath(task, workspaceRoot);
-                    prompt = fs.readFileSync(resolvedTask, 'utf-8');
-                }
-                catch (err) {
-                    return {
-                        content: [{ type: 'text', text: `Error reading task file: ${err}` }],
-                    };
-                }
-            }
-            // Determine which agent to use — fallback if requested not available
-            let usedAgent = agent;
-            let fallbackReason;
-            if (!commandExists(agent)) {
-                const fallback = agent === 'gemini' ? 'claude' : 'gemini';
-                if (commandExists(fallback)) {
-                    usedAgent = fallback;
-                    fallbackReason = `${agent} CLI not installed, fell back to ${fallback}`;
-                }
-                else {
-                    const installHint = agent === 'gemini'
-                        ? 'Install Gemini CLI: https://github.com/google-gemini/gemini-cli'
-                        : 'Install Claude CLI: npm install -g @anthropic-ai/claude-code';
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: JSON.stringify({
-                                    agent,
-                                    status: 'error',
-                                    output: '',
-                                    error: `Neither ${agent} nor the fallback agent CLI is installed. ${installHint}`,
-                                }, null, 2),
-                            },
-                        ],
-                    };
-                }
-            }
-            // Execute the agent CLI with the prompt
-            const output = execFileSync(usedAgent, ['-p', prompt], {
-                encoding: 'utf8',
-                timeout: AGENT_TIMEOUT,
-                maxBuffer: 10 * 1024 * 1024, // 10MB
-                cwd: workspaceRoot,
-            });
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            agent: usedAgent,
-                            status: fallbackReason ? 'fallback' : 'success',
-                            output,
-                            ...(fallbackReason && { fallback_reason: fallbackReason }),
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            const msg = error instanceof Error ? error.message : String(error);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            agent,
-                            status: 'error',
-                            output: '',
-                            error: msg,
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-    });
-}

package/dist/tools/orchestration.d.ts

@@ -1,9 +0,0 @@
-/**
- * Core Tools - Project context, handoff, and artifact management
- * Extracted from kit-server.ts for better modularity
- */
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-/**
- * Register core tools with MCP server
- */
-export declare function registrerOrchestrationTools(server: McpServer): void;

package/dist/tools/orchestration.js

@@ -1,168 +0,0 @@
-/**
- * Core Tools - Project context, handoff, and artifact management
- * Extracted from kit-server.ts for better modularity
- */
-import * as fs from 'fs';
-import * as path from 'path';
-import { z } from 'zod';
-import { getExtensionRoot, getWorkspaceRoot } from '../utils.js';
-import { WORKFLOWS } from '../workflows.js';
-/**
- * Resolve lifecycle configuration (Project > Extension)
- */
-function getWorkflows() {
-    return WORKFLOWS;
-}
-/**
- * Register core tools with MCP server
- */
-export function registrerOrchestrationTools(server) {
-    // ═══════════════════════════════════════════════════════════════
-    // TOOL: GET NEXT PHASE
-    // Persists the rolling summary and returns transition instructions
-    // ═══════════════════════════════════════════════════════════════
-    server.tool('kit_get_next_phase', 'Persists the rolling summary and returns transition instructions. currentPhase format: "workflow:phase" (e.g., "code:ANALYSIS")', {
-        summary: z.object({
-            original_goal: z.string(),
-            completed_tasks: z.array(z.string()),
-            pending_tasks: z.array(z.string()),
-            current_context_brief: z.string(),
-        }),
-        transitionTo: z
-            .string()
-            .optional()
-            .describe('Force transition to a specific phase (e.g., "INGESTION")'),
-        currentPhase: z.string().describe('The current workflow and phase (e.g., "code:ANALYSIS")'),
-    }, async ({ summary, transitionTo, currentPhase }) => {
-        try {
-            const [workflowId, phaseId] = currentPhase.split(':');
-            if (!workflowId) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: '❌ Invalid currentPhase format. Use "workflowId" or "workflow:phase".',
-                        },
-                    ],
-                };
-            }
-            const handoffDir = path.join(getWorkspaceRoot(), '.claude-kit', 'handoffs', 'active');
-            const summaryPath = path.join(handoffDir, `${workflowId}-summary.md`);
-            // 1. Ensure directory exists
-            if (!fs.existsSync(handoffDir)) {
-                fs.mkdirSync(handoffDir, { recursive: true });
-            }
-            // 2. Format Markdown
-            const markdown = `
-# 📝 Rolling Summary: ${workflowId.toUpperCase()} Workflow
-
-## 🎯 Original Goal
-${summary.original_goal}
-
-## ✅ Completed Tasks
-${summary.completed_tasks.map((t) => `- ${t}`).join('\n')}
-
-## ⏳ Pending Tasks
-${summary.pending_tasks.map((t) => `- ${t}`).join('\n')}
-
-## 🧠 Current Context Brief
-${summary.current_context_brief}
-
----
-*Updated: ${new Date().toLocaleString()}*
-`;
-            // 3. Persist summary
-            fs.writeFileSync(summaryPath, markdown, 'utf8');
-            // 4. Resolve next state
-            const workflows = getWorkflows();
-            let nextPhaseId = null;
-            if (workflows[workflowId]) {
-                const workflow = workflows[workflowId];
-                const currentState = phaseId ? workflow.states[phaseId] : null;
-                // Handle bootstrap case: if phaseId is missing, fallback to initial
-                if (!currentState) {
-                    nextPhaseId = transitionTo || workflow.initial;
-                }
-                else {
-                    nextPhaseId = transitionTo || currentState?.next || null;
-                }
-                if (nextPhaseId && !workflow.states[nextPhaseId]) {
-                    nextPhaseId = null;
-                }
-            }
-            // 5. Persist machine-readable state
-            const statePath = path.join(handoffDir, `${workflowId}-state.json`);
-            const stateData = {
-                workflowId,
-                currentPhase: phaseId || 'START',
-                nextPhase: nextPhaseId,
-                summary,
-                updatedAt: new Date().toISOString(),
-            };
-            fs.writeFileSync(statePath, JSON.stringify(stateData, null, 2), 'utf8');
-            // 6. Return transition instructions
-            if (!workflows[workflowId]) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: `✅ Summary persisted to ${summaryPath}.\n⚠️ Warning: Workflow "${workflowId}" not found in lifecycle.json.`,
-                        },
-                    ],
-                };
-            }
-            const workflow = workflows[workflowId];
-            if (!nextPhaseId || !workflow.states[nextPhaseId]) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: `✅ Summary persisted. Workflow: ${workflowId}, Phase: ${phaseId || 'START'}. No next phase defined.`,
-                        },
-                    ],
-                };
-            }
-            const currentState = phaseId ? workflow.states[phaseId] : null;
-            const nextState = workflow.states[nextPhaseId];
-            const extensionRoot = getExtensionRoot();
-            // Resolve agent content only if it changes
-            const currentAgent = currentState?.agent || workflow.agent;
-            const nextAgent = nextState.agent || workflow.agent;
-            let agentContent = '[UNCHANGED]';
-            if (nextAgent && nextAgent !== currentAgent) {
-                const agentPath = path.join(extensionRoot, 'agents', nextAgent + '.md');
-                if (fs.existsSync(agentPath)) {
-                    agentContent = fs.readFileSync(agentPath, 'utf8');
-                }
-                else {
-                    agentContent = `⚠️ Warning: Agent persona file not found at ${agentPath}`;
-                }
-            }
-            else if (nextAgent && !currentState) {
-                // First phase transition (bootstrap)
-                const agentPath = path.join(extensionRoot, 'agents', nextAgent + '.md');
-                if (fs.existsSync(agentPath)) {
-                    agentContent = fs.readFileSync(agentPath, 'utf8');
-                }
-            }
-            const nextInstructions = `${nextState.instructions}\n\n**PHASE_STOP:** You MUST STOP immediately after completing the instructions above. Do not speculate, do not perform any "extra" work, and do not initiate the next phase. Summarize your progress and call 'kit_get_next_phase' to transition, or WAIT for user feedback if you need to ask_user or a gate is present.`;
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `PHASE_TRANSITION:
-Next Phase: ${workflowId}:${nextPhaseId}
-Agent Content: ${agentContent}
-Skills: ${JSON.stringify(nextState.skills || [])}
-Instructions: ${nextInstructions}`,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [{ type: 'text', text: `Error updating summary/transition: ${error}` }],
-            };
-        }
-    });
-}

package/dist/workflows.d.ts

@@ -1,2 +0,0 @@
-import { Workflows } from './tools/config.js';
-export declare const WORKFLOWS: Workflows;

package/dist/workflows.js

@@ -1,268 +0,0 @@
-import dedent from 'dedent';
-const CODE_WORKFLOW = {
-    initial: 'PLAN_ANALYSIS',
-    agent: 'coder',
-    states: {
-        PLAN_ANALYSIS: {
-            instructions: dedent `
-        1. **Mandate:** You must understand the target and the constraints.
-        2. **Action:** Read the 'Target Input' (Implementation Plan). If the input is a file path, use 'read_file' to ingest its content.
-      `,
-            next: 'EXECUTION_AND_TESTING',
-            skills: [],
-        },
-        EXECUTION_AND_TESTING: {
-            instructions: dedent `
-        1. **Mandate:** You must now implement the changes defined in the 'Implementation Plan'.
-        2. **Execution:**
-          - For each file listed in the plan, use 'read_file' to get the current content.
-          - Apply the necessary modifications (additions, deletions, replacements).
-          - Use 'write_file' to save the updated content.
-        3. **Constraint:** Do not invent new files or change file paths unless explicitly required by the plan.
-        4. **Testing:**
-          - Decide whether to create unit tests based on '.claude-kit/stats.json' (hasUnitTests).
-          - If hasUnitTests is true, create or update '.test' or '.spec' files for the modified logic, covering primary paths and edge cases.
-      `,
-            next: 'VALIDATION_AND_HANDOFF',
-            skills: ['coding-common'],
-        },
-        VALIDATION_AND_HANDOFF: {
-            instructions: dedent `
-        1. **Self-Check:** Review the generated code for syntax errors, missing imports, or logic gaps.
-          - You MUST rely on the project's standard task runners with auto-fix priority (e.g., 'npm run lint', 'yarn test', 'make lint').
-          - FORBIDDEN: DO NOT attempt to guess or directly invoke underlying binary tools (like eslint, prettier, gulp, webpack, etc.).
-          - FORBIDDEN: DO NOT reverse-engineer or inspect build configuration files (e.g., webpack.config, gulpfile, settings.json) to understand how the project compiles.
-        2. **Synthesis:** Confirm if the Plan is 100% complete or if certain parts were blocked.
-        3. **Formatting:** Structure the entire output strictly according to the 'Output Format'.
-        4. **Persistence:** If required, save modified files or provide instructions for the user to apply the diff.
-      `,
-            next: null,
-            skills: [],
-        },
-    },
-};
-const BRAINSTORM_WORKFLOW = {
-    initial: 'CONTEXT_INGESTION',
-    agent: 'brainstormer',
-    states: {
-        CONTEXT_INGESTION: {
-            instructions: dedent `
-        1. **Objective:** Understand the "Why" and the "Status Quo".
-        2. **Action:** Read provided context, previous files, or user prompts. Output **State 1**.
-        3. **Questions to ask:**
-          - What is the specific pain point? (Desperate Specificity)
-          - What happens if we do nothing? (Status Quo)
-          - Is there existing code/infrastructure we can leverage?
-        4. **Gate:** Do not proceed to the next phase until the user clearly defines the core problem and agrees on the premise.
-      `,
-            next: 'EXPANSION_VS_MINIMUM',
-            skills: [],
-        },
-        EXPANSION_VS_MINIMUM: {
-            instructions: dedent `
-        1. **Objective:** Stretch the idea to its maximum potential, then compress it to its most actionable form.
-        2. **Action:** Output **State 1**. Present the "10-Star Vision" (Scope Expansion) alongside the "Narrowest Wedge" (Scope Reduction).
-        3. **Questions to ask:**
-          - Do we build the Minimum Viable version for speed, or do we invest in the 10x Architecture now?
-          - What is the "Delight factor" (What makes the user say "whoa")?
-        4. **Gate:** The user MUST make a decision on the scope mode (Expansion, Selective, or Minimum Wedge). Lock the scope.
-      `,
-            next: 'ARCH_ALTERNATIVES',
-            skills: [],
-        },
-        ARCH_ALTERNATIVES: {
-            instructions: dedent `
-        1. **Objective:** Propose concrete ways to build the locked scope.
-        2. **Action:** Present exactly 2 to 3 distinct implementation approaches using the 'AskUserQuestion' format.
-          - *Approach A (Minimal):* Quickest time-to-market, leverages existing tools heavily.
-          - *Approach B (Ideal):* Scalable, robust, "boring by default" technology.
-          - *Approach C (Creative):* A lateral thinking approach (if applicable).
-        3. **Gate:** User must explicitly choose one approach.
-      `,
-            next: 'BOUNDARIES_MAPPING',
-            skills: [],
-        },
-        BOUNDARIES_MAPPING: {
-            instructions: dedent `
-        1. **Objective:** Map the shadow paths. Ideas are easy; handling failures is hard.
-        2. **Action:** Analyze the chosen approach. What happens on 'nil'? What happens on 'timeout'? What happens on 'empty state'? What features are tempting but dangerous to include right now?
-        3. **Output:** Define the strict "NOT in scope" list.
-      `,
-            next: 'HANDOFF',
-            skills: [],
-        },
-        HANDOFF: {
-            instructions: dedent `
-        1. **Objective:** Consolidate all decisions into a single source of truth for engineering.
-        2. **Action:** Transition to **State 2: Engineer-Ready PRD & HLD**.
-        3. **Constraint:** Ensure the document is brutally clear. The ASCII diagram must exist. The Failure Modes table must be populated based on the previous phase.
-        4. **Persistence:** Save the finalized decision, including the ASCII diagram and reasoning, to '.claude-kit/handoffs/brainstorms/brainstorm-[timestamp]-[slug].md'.
-        5. **Handoff:** Request explicit user approval ("Approve") before ending the pipeline.
-      `,
-            next: null,
-            skills: [],
-        },
-    },
-};
-const REVIEW_WORKFLOW = {
-    initial: 'CONTEXT_DRIFT',
-    agent: 'reviewer',
-    states: {
-        CONTEXT_DRIFT: {
-            instructions: dedent `
-        1. **Objective:** Understand *what* is being built and *why*, before looking at *how*.
-        2. **Action:** Read the Jira ticket description or PR summary provided in the context. Run the 'diff' to analyze the files changed.
-        3. **Decision Gate:**
-          - Compare the actual code changes against the Jira ticket intent.
-          - Identify **Scope Drift**: Are there new features, unrelated refactors, or massive architecture changes not requested in the ticket?
-          - Identify **Missing Requirements**: Did they skip a core acceptance criteria from the ticket?
-        4. **Persistence:** Store the "Scope Check" result in memory for the final report.
-      `,
-            next: 'MACRO_REVIEW',
-            skills: [],
-        },
-        MACRO_REVIEW: {
-            instructions: dedent `
-        1. **Objective:** Evaluate the forest before the trees.
-        2. **Action:** Analyze the overall architectural choices.
-          - Does this PR introduce new complexity that isn't justified?
-          - Are models/services interacting correctly?
-          - Is there over-engineering?
-        3. **Rule:** If the design is fundamentally flawed, record this as a **BLOCKER** and proceed to the next phase with a strict lens.
-      `,
-            next: 'MICRO_BLOCKERS',
-            skills: [],
-        },
-        MICRO_BLOCKERS: {
-            instructions: dedent `
-        1. **Objective:** Hunt for system-breaking bugs.
-        2. **Action:** Scan the diff specifically for:
-          - **SQL & Data Safety**: Direct DB writes bypassing validations, SQL string interpolation.
-          - **Race Conditions**: Check-then-set patterns, lack of atomic operations.
-          - **LLM/Trust Boundaries**: Unvalidated output from LLMs or external APIs being executed or persisted.
-          - **Enum/Completeness**: Did they add a new status but forget to handle it in existing switch statements?
-        3. **Classification:** Every finding here must be logged as a **BLOCKER**.
-      `,
-            next: 'MICRO_NITPICKS',
-            skills: [],
-        },
-        MICRO_NITPICKS: {
-            instructions: dedent `
-        1. **Objective:** Enforce codebase health, readability, and test parity.
-        2. **Action:** Scan the diff for:
-          - **Test Gaps**: New logic paths without corresponding unit/integration tests.
-          - **Side Effects**: Hidden state mutations in seemingly pure functions.
-          - **Dead Code**: Unused variables, lingering 'console.log' or debug statements.
-          - **Clean Code**: Magic numbers, poor naming conventions, bloated controllers.
-        3. **Classification:** Findings here are logged as **CONCERNS** (if tests are missing) or **NITPICKS** (for style/naming).
-      `,
-            next: 'HANDOFF',
-            skills: [],
-        },
-        HANDOFF: {
-            instructions: dedent `
-        1. **Objective:** Deliver the final actionable verdict to the developer.
-        2. **Action:** Synthesize findings from previous phases.
-        3. **Constraint:** Format the output STRICTLY matching the 'Final PR Review Report' state defined in the 'code-reviewer' persona.
-          - If there is at least one BLOCKER, the Verdict MUST be 'REQUEST CHANGES'.
-          - If there are only NITPICKS, the Verdict can be 'APPROVE' with comments.
-        4. **Handoff:** Conclude the review. No further code generation is allowed unless the user explicitly requests a code patch.
-      `,
-            next: null,
-            skills: [],
-        },
-    },
-};
-const PLAN_WORKFLOW = {
-    initial: 'CONTEXT_SCOPE',
-    agent: 'planner',
-    states: {
-        CONTEXT_SCOPE: {
-            instructions: dedent `
-        1. **Objective:** Gather comprehensive context to understand the structural impact of the request.
-        2. **Action:**
-          - Deep-dive into arguments, attached files, and JSON schemas.
-          - Identify exactly which modules will be affected (Blast Radius Assessment).
-          - Answer: What already exists? Are we over-engineering? Are we adhering to the Completeness Principle?
-      `,
-            next: 'ENG_REVIEW',
-            skills: [],
-        },
-        ENG_REVIEW: {
-            instructions: dedent `
-        1. **Action:** Evaluate 4 critical pillars:
-          - **Architecture**: Dependency graphs, module boundaries.
-          - **Code Quality**: DRY violations, error handling patterns.
-          - **Tests**: Ensure every new branch/logic path has a test requirement.
-          - **Performance**: N+1 issues, memory, caching.
-        2. **Decision Gate:** Use the 'ask_user' format to resolve architectural ambiguities or scope bloat.
-        3. **Constraint:** Never batch questions. Wait for the user's explicit response before proceeding.
-      `,
-            next: 'SKILL_ROUTING',
-            skills: [],
-        },
-        SKILL_ROUTING: {
-            instructions: dedent `
-        1. **Action:** Route to specific internal domain skills if necessary (e.g., 'frontend-arch', 'backend-arch', 'security') to validate the final approach.
-        2. **Action:** Map out the exact failure modes and the ASCII diagram representing the data flow.
-      `,
-            next: 'BLUEPRINT_GEN',
-            skills: [],
-        },
-        BLUEPRINT_GEN: {
-            instructions: dedent `
-        1. **Action:** Transition to 'Intern-Proof Blueprint State'.
-        2. **Constraint:** Draft the Work Breakdown Structure (WBS) strictly from the bottom up.
-          - Tasks must be granular enough for a Junior Engineer.
-          - Use explicit instructions like "Map the array of 'User' objects to 'UserDTO'..."
-        3. **Constraint:** Ensure the **Test Plan Artifact** and **NOT in Scope** sections are strictly populated.
-      `,
-            next: 'PERSISTENCE_HANDOFF',
-            skills: [],
-        },
-        PERSISTENCE_HANDOFF: {
-            instructions: dedent `
-        1. **Constraint Check:** Verify that NO source code has been modified during the planning session.
-        2. **Action:** Save the generated blueprint to '.claude-kit/handoffs/plans/plan-[timestamp]-[feature].md'.
-        3. **Handoff:** Request explicit user approval. Upon receiving "Approve", output the exact command for the coder agent: '/code @.claude-kit/handoffs/plans/[filename].md'.
-      `,
-            next: null,
-            skills: [],
-        },
-    },
-};
-const TICKET_WORKFLOW = {
-    initial: 'DATA_ACQUISITION',
-    states: {
-        DATA_ACQUISITION: {
-            instructions: dedent `
-        1. **Input Normalization:** Extract TICKET_ID (regex [A-Z]+-[0-9]+).
-        2. **Fetch Data:** Use 'kit_jira_get_ticket' with the TICKET_ID to retrieve ticket details.
-        3. **Persistence:** Save raw ticket data to '.claude-kit/handoffs/tickets/{{TICKET_ID}}.md'.
-      `,
-            next: 'HANDOFF',
-            skills: [],
-        },
-        HANDOFF: {
-            instructions: dedent `
-        1. **Objective:** Output ONLY the Report using the template.
-        2. **Template:**
-          ### 🎟️ Ticket Report: {{TICKET_ID}}
-          - **Type:** [Classified Intent or Incomplete Requirement]
-          - **Summary:** [1-sentence technical summary]
-          ---
-          ### 🚀 Recommended Next Action
-          /plan @.claude-kit/handoffs/tickets/{{TICKET_ID}}.md
-      `,
-            next: null,
-            skills: [],
-        },
-    },
-};
-export const WORKFLOWS = {
-    brainstorm: BRAINSTORM_WORKFLOW,
-    review: REVIEW_WORKFLOW,
-    plan: PLAN_WORKFLOW,
-    code: CODE_WORKFLOW,
-    ticket: TICKET_WORKFLOW,
-};