@vodailoc/kilo-kit-mcp 1.2.0 → 1.3.0

package/README.md

@@ -23,8 +23,8 @@
 
 # 🚀 Kilo-Kit: Professional AI Agent Development Framework
 
-> **Version:** 1.0.0  
-> **Author:** Kilo-Kit Team  
+> **Version:** 1.3.0
+> **Author:** Kilo-Kit Team
 > **License:** Apache 2.0
 
 ## 🎯 What is Kilo-Kit?
@@ -196,11 +196,11 @@ Skills are automatically loaded when your task matches their keywords. See the [
 
 ## 🔌 MCP Integration
 
-Kilo-Kit v1.2.0 includes a read-only MCP server that exposes the skill library as an adaptive routing service for MCP-capable agents.
+Kilo-Kit v1.3.0 includes a read-only MCP server that exposes the skill library as an adaptive routing service for MCP-capable agents.
 
 | MCP Surface | Purpose |
 |-------------|---------|
-| `kilo_orchestrate_task` | C4 central gate: route internally, require brainstorming, ask questions, check memory, and release final workflow |
+| `kilo_orchestrate_task` | C4 central gate: require the real `/brainstorming` skill first, then log/route the approved task and release the post-brainstorming workflow |
 | `kilo_route_intent` | Route the current chat request to skills, workflow order, rule hierarchy, and decision trail |
 | `kilo_search_skills` | Search the skill catalog by task or keyword |
 | `kilo_get_skill` | Load one exact `SKILL.md` with context-safe truncation |
@@ -277,7 +277,7 @@ Kilo-Kit publishes `@vodailoc/kilo-kit-mcp` through npm Trusted Publishing. Conf
 | Repository | `VoDaiLocz/KILO-KIT` |
 | Workflow filename | `publish.yml` |
 
-After that, run the GitHub Actions workflow `Publish npm package`, or push a version tag such as `v1.2.0`. The workflow uses OIDC, so it does not need an npm token or interactive OTP.
+After that, run the GitHub Actions workflow `Publish npm package`, or push a version tag such as `v1.3.0`. The workflow uses OIDC, so it does not need an npm token or interactive OTP.
 
 ## 📋 Skill Dispatch Table
 
@@ -435,7 +435,8 @@ We welcome contributions! Please read [CONTRIBUTING.md](./CONTRIBUTING.md) for:
 
 - [x] v1.0.0 - Core Cognitive Flow Architecture
 - [x] v1.1.0 - MCP Integration
-- [ ] v1.2.0 - Multi-Agent Orchestration
+- [x] v1.2.0 - Multi-Agent Orchestration
+- [x] v1.3.0 - Primary Brainstorming Gate for C4
 - [ ] v2.0.0 - Visual Workflow Builder
 
 ## 📄 License

package/mcp/README.md

@@ -1,6 +1,6 @@
 # 🔌 Kilo-Kit MCP Server
 
-> **Version:** 1.2.0
+> **Version:** 1.3.0
 > **Mode:** Read-only Skill Registry + Validator
 > **Transport:** stdio
 
@@ -12,7 +12,7 @@ The Kilo-Kit MCP server exposes the `skills/` workflow surface to MCP-capable ag
 
 | Capability | MCP Tool | Purpose |
 |------------|----------|---------|
-| C4 orchestration | `kilo_orchestrate_task` | Enforce brainstorming-first workflow, required questions, memory suggestions, and final workflow release |
+| C4 orchestration | `kilo_orchestrate_task` | Require the real `/brainstorming` skill before substantive work, then log/route the approved task and release the post-brainstorming workflow |
 | Skill discovery | `kilo_search_skills` | Search the skill library by task/query |
 | Intent routing | `kilo_route_intent` | Recommend skills, workflow order, rule hierarchy, and decision trail for the current chat context |
 | Skill loading | `kilo_get_skill` | Load one exact `SKILL.md` with output limits |
@@ -91,7 +91,7 @@ KILO_KIT_MEMORY_PATH=/absolute/path/orchestrator.sqlite
 KILO_KIT_ORCHESTRATION_AUDIT_PATH=/absolute/path/orchestration-audit.jsonl
 ```
 
-`kilo_orchestrate_task` uses the C4 Brainstorming-First Gate: substantive work starts with `productivity/brainstorming`, then required questions, then memory suggestions that require explicit accept/reject before a final workflow is released.
+`kilo_orchestrate_task` uses the C4 Brainstorming-First Gate as a skill gate, not a separate C4 questionnaire. Substantive work starts by loading and following `productivity/brainstorming`. After the user approves the brainstorming direction, call `kilo_orchestrate_task` again with `brainstormingApproved=true`; C4 then checks memory suggestions and releases the post-brainstorming workflow.
 
 ### Codex CLI on Windows
 
@@ -120,8 +120,8 @@ Configure the npm package once:
 Then publish by running the GitHub Actions workflow `Publish npm package`, or by pushing a version tag:
 
 ```bash
-git tag v1.2.0
-git push origin v1.2.0
+git tag v1.3.0
+git push origin v1.3.0
 ```
 
 The workflow runs build, typecheck, tests, smoke, skill validation, package dry-run, and then `npm publish --access public --ignore-scripts` through OIDC.
@@ -173,10 +173,11 @@ Use `.mcp/kilo-kit.example.json` as the portable template.
 
 ```text
 User request
-→ kilo_orchestrate_task(message, context)
-→ answer required C4 questions
-→ accept/reject memory suggestions
-→ kilo_get_skill(category, skill) for the first workflow skill
+→ kilo_get_skill(productivity, brainstorming)
+→ follow the real /brainstorming hard gate and get user approval
+→ kilo_orchestrate_task(message, context, brainstormingApproved=true)
+→ accept/reject memory suggestions when relevant
+→ kilo_get_skill(category, skill) for the first post-brainstorming workflow skill
 → follow final workflow skills in order
 → kilo_route_report when you need routing analytics
 → kilo_memory_report when you need memory analytics

package/mcp/dist/formatters.js

@@ -137,11 +137,9 @@ export function formatOrchestration(result, format) {
     if (format === "json") {
         return JSON.stringify(result, null, 2);
     }
-    const questions = result.questions.length > 0
-        ? result.questions
-            .map((question, index) => `${index + 1}. **${question.id}**${question.required ? " (required)" : ""}\n   ${question.prompt}`)
-            .join("\n")
-        : "No questions required.";
+    const brainstormingGate = result.state === "brainstorming_required"
+        ? "Load `productivity/brainstorming` and follow the real skill hard-gate. C4 questions are not used as a separate questionnaire."
+        : "Brainstorming approval has been recorded or this is a read-only route.";
     const workflow = result.workflow.length > 0
         ? result.workflow.map((step, index) => `${index + 1}. **${step.skill.id}** (${step.role})\n   ${step.reason}`).join("\n")
         : "No workflow selected.";
@@ -160,8 +158,8 @@ export function formatOrchestration(result, format) {
         `State: \`${result.state}\``,
         `Task mode: \`${result.taskMode}\``,
         "",
-        "## Questions",
-        questions,
+        "## Brainstorming Gate",
+        brainstormingGate,
         "",
         "## Workflow",
         workflow,

package/mcp/dist/orchestrator.js

@@ -1,6 +1,5 @@
 import { randomUUID } from "node:crypto";
 import { createNoopOrchestrationAudit } from "./orchestration-audit.js";
-import { selectQuestionTemplate } from "./question-templates.js";
 import { routeIntent } from "./router.js";
 export function createOrchestrator(options) {
     const sessions = new Map();
@@ -9,18 +8,18 @@ export function createOrchestrator(options) {
         orchestrate(input) {
             const session = getOrCreateSession(sessions, options.registry, input);
             mergeInput(session, input);
-            const missingInfo = missingRequiredQuestionIds(session.questions, session.answers);
+            const missingInfo = [];
             const suggestions = ensureMemorySuggestions(options.memory, session);
             const pendingSuggestions = suggestions.filter((suggestion) => session.memoryConfirmations[suggestion.key] === undefined);
             const acceptedSuggestions = suggestions.filter((suggestion) => session.memoryConfirmations[suggestion.key] === "accepted");
-            const state = selectState(session, missingInfo, pendingSuggestions);
+            const state = selectState(session, pendingSuggestions);
             for (const [suggestionKey, decision] of Object.entries(input.memoryConfirmations ?? {})) {
                 options.memory.recordDecision({ suggestionKey, decision });
             }
             const verificationGate = buildVerificationGate(acceptedSuggestions);
-            const finalWorkflow = state === "ready" ? session.workflow : undefined;
-            const firstSkillToLoad = finalWorkflow?.[0]?.skill;
-            const nextAction = buildNextAction(state, session, missingInfo, pendingSuggestions, firstSkillToLoad);
+            const finalWorkflow = state === "ready" ? executableWorkflow(session) : undefined;
+            const firstSkillToLoad = state === "brainstorming_required" ? findSkillById(options.registry, "productivity/brainstorming") : finalWorkflow?.[0]?.skill;
+            const nextAction = buildNextAction(state, session, pendingSuggestions, firstSkillToLoad);
             persistSession(options.memory, session, state, verificationGate, finalWorkflow);
             const auditRef = audit.record({
                 sessionId: session.sessionId,
@@ -34,7 +33,7 @@ export function createOrchestrator(options) {
                 state,
                 message: session.message,
                 taskMode: session.route.taskMode,
-                questions: session.questions,
+                questions: [],
                 missingInfo,
                 route: session.route,
                 workflow: session.workflow,
@@ -66,18 +65,13 @@ function getOrCreateSession(sessions, registry, input) {
         limit: 5,
     });
     const workflow = ensureBrainstormingFirst(registry, route.workflow, input);
-    const template = selectQuestionTemplate({
-        taskMode: route.taskMode,
-        workflowSkillIds: workflow.map((step) => step.skill.id),
-        recommendedSkillIds: route.recommended.map((item) => item.skill.id),
-    });
     const session = {
         sessionId: input.sessionId ?? randomUUID(),
         message: input.message,
         createdAt: new Date().toISOString(),
         route,
         workflow,
-        questions: template.questions,
+        brainstormingApproved: input.brainstormingApproved === true,
         answers: {},
         memorySuggestions: [],
         memoryConfirmations: {},
@@ -94,7 +88,7 @@ function persistSession(memory, session, state, verificationGate, finalWorkflow)
         message: session.message,
         taskMode: session.route.taskMode,
         route: toJsonObject(session.route),
-        questions: toJsonArray(session.questions),
+        questions: [],
         answers: { ...session.answers },
         memorySuggestions: session.memorySuggestions.map((suggestion) => ({ ...suggestion })),
         finalWorkflow: toJsonArray(finalWorkflow ?? []),
@@ -116,6 +110,7 @@ function persistSession(memory, session, state, verificationGate, finalWorkflow)
 function mergeInput(session, input) {
     session.message = input.message || session.message;
     session.answers = { ...session.answers, ...(input.answers ?? {}) };
+    session.brainstormingApproved = session.brainstormingApproved || input.brainstormingApproved === true;
     session.memoryConfirmations = { ...session.memoryConfirmations, ...(input.memoryConfirmations ?? {}) };
     if (input.context) {
         session.context = input.context;
@@ -132,13 +127,10 @@ function ensureMemorySuggestions(memory, session) {
     });
     return session.memorySuggestions;
 }
-function selectState(session, missingInfo, pendingSuggestions) {
-    if (isSubstantiveWork(session) && Object.keys(session.answers).length === 0) {
+function selectState(session, pendingSuggestions) {
+    if (isSubstantiveWork(session) && !session.brainstormingApproved) {
         return "brainstorming_required";
     }
-    if (missingInfo.length > 0) {
-        return "questioning";
-    }
     if (pendingSuggestions.length > 0) {
         return "awaiting_memory_confirmation";
     }
@@ -153,7 +145,7 @@ function ensureBrainstormingFirst(registry, workflow, input) {
     const step = {
         skill: brainstorming,
         role: "prepare",
-        reason: "C4 Brainstorming-First Gate requires design clarification before substantive work.",
+        reason: "Load and follow the real /brainstorming skill before substantive work.",
     };
     if (input.context?.mode === "brainstorming" || /\bbrainstorm(?:ing)?\b/i.test(input.message)) {
         return [step, ...existing];
@@ -175,12 +167,6 @@ function findSkillById(registry, id) {
         return undefined;
     }
 }
-function missingRequiredQuestionIds(questions, answers) {
-    return questions
-        .filter((question) => question.required)
-        .filter((question) => !answers[question.id]?.trim())
-        .map((question) => question.id);
-}
 function buildVerificationGate(acceptedSuggestions) {
     const commands = acceptedSuggestions.flatMap((suggestion) => {
         const commands = suggestion.value.commands;
@@ -193,12 +179,9 @@ function buildVerificationGate(acceptedSuggestions) {
             : "Default MCP verification gate for C4 orchestration.",
     };
 }
-function buildNextAction(state, session, missingInfo, pendingSuggestions, firstSkillToLoad) {
+function buildNextAction(state, session, pendingSuggestions, firstSkillToLoad) {
     if (state === "brainstorming_required") {
-        return `Start with productivity/brainstorming and answer required C4 questions: ${missingInfo.join(", ")}.`;
-    }
-    if (state === "questioning") {
-        return `Answer missing C4 questions before workflow execution: ${missingInfo.join(", ")}.`;
+        return "Load productivity/brainstorming with kilo_get_skill, follow its hard-gate, get user approval, then call kilo_orchestrate_task again with brainstormingApproved=true.";
     }
     if (state === "awaiting_memory_confirmation") {
         return `Accept or reject memory suggestions before execution: ${pendingSuggestions.map((item) => item.key).join(", ")}.`;
@@ -208,6 +191,12 @@ function buildNextAction(state, session, missingInfo, pendingSuggestions, firstS
     }
     return session.route.nextAction;
 }
+function executableWorkflow(session) {
+    if (!session.brainstormingApproved) {
+        return session.workflow;
+    }
+    return session.workflow.filter((step) => step.skill.id !== "productivity/brainstorming");
+}
 function isSubstantiveWork(session) {
     return !isReadOnlyRequest(session.message);
 }

package/mcp/dist/server.js

@@ -15,7 +15,7 @@ import { createInMemoryRouteAnalytics, createJsonlRouteAnalytics } from "./route
 import { createSkillRegistry } from "./registry.js";
 import { routeIntent } from "./router.js";
 import { validateSkills } from "./validator.js";
-const SERVER_VERSION = "1.2.0";
+const SERVER_VERSION = "1.3.0";
 const DEFAULT_REPO_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
 const formatSchema = z.enum(["markdown", "json"]).default("markdown");
 export async function createKiloKitServer(options = {}) {
@@ -47,7 +47,7 @@ export async function createKiloKitServer(options = {}) {
     });
     server.registerTool("kilo_orchestrate_task", {
         title: "Kilo-Kit C4 Orchestrate Task",
-        description: "Central C4 orchestration gate. Routes internally, enforces brainstorming-first, asks required questions, checks memory suggestions, and releases a final workflow only after confirmation.",
+        description: "Central C4 orchestration gate. Routes internally, requires the real /brainstorming skill before substantive work, checks memory suggestions, and releases the post-brainstorming workflow after approval.",
         inputSchema: {
             message: z.string().min(1).max(4000).describe("Current user request or task summary."),
             context: z
@@ -59,6 +59,7 @@ export async function createKiloKitServer(options = {}) {
             })
                 .optional(),
             sessionId: z.string().min(1).max(120).optional(),
+            brainstormingApproved: z.boolean().optional(),
             answers: z.record(z.string().max(2000)).optional(),
             memoryConfirmations: z.record(z.enum(["accepted", "rejected"])).optional(),
             format: formatSchema.optional(),
@@ -68,7 +69,7 @@ export async function createKiloKitServer(options = {}) {
             destructiveHint: false,
             idempotentHint: false,
         },
-    }, async ({ message, context, sessionId, answers, memoryConfirmations, format }) => {
+    }, async ({ message, context, sessionId, brainstormingApproved, answers, memoryConfirmations, format }) => {
         const result = orchestrator.orchestrate({
             message,
             ...(context
@@ -82,6 +83,7 @@ export async function createKiloKitServer(options = {}) {
                 }
                 : {}),
             ...(sessionId ? { sessionId } : {}),
+            ...(brainstormingApproved !== undefined ? { brainstormingApproved } : {}),
             ...(answers ? { answers } : {}),
             ...(memoryConfirmations ? { memoryConfirmations } : {}),
         });

package/mcp/dist/smoke.js

@@ -59,31 +59,28 @@ try {
     if (orchestrationResult.workflow?.[0]?.skill?.id !== "productivity/brainstorming") {
         throw new Error(`Smoke orchestration did not start with brainstorming: ${orchestrationText}`);
     }
-    if (!orchestrationResult.questions?.some((question) => question.id === "test_command" || question.skillId === "engineering/tdd")) {
-        throw new Error(`Smoke orchestration did not include TDD questions: ${orchestrationText}`);
+    if (orchestrationResult.firstSkillToLoad?.id !== "productivity/brainstorming") {
+        throw new Error(`Smoke orchestration did not instruct loading brainstorming: ${orchestrationText}`);
+    }
+    if ((orchestrationResult.questions?.length ?? 0) !== 0 || (orchestrationResult.missingInfo?.length ?? 0) !== 0) {
+        throw new Error(`Smoke orchestration should not use C4 questions as a gate: ${orchestrationText}`);
     }
     const readyOrchestration = await client.callTool({
         name: "kilo_orchestrate_task",
         arguments: {
             message: "Fix bug login, viết test trước",
             sessionId: orchestrationResult.sessionId,
-            answers: {
-                goal: "Fix login failure",
-                scope: "src/auth/login.ts",
-                success_criteria: "login test passes",
-                failing_behavior: "valid credentials are rejected",
-                test_command: "npm test -- login",
-            },
+            brainstormingApproved: true,
             format: "json",
         },
     });
     const readyText = extractFirstText(readyOrchestration);
     const readyResult = JSON.parse(readyText);
-    if (readyResult.state !== "ready" || readyResult.firstSkillToLoad?.id !== "productivity/brainstorming") {
-        throw new Error(`Smoke orchestration did not release final workflow after answers: ${readyText}`);
+    if (readyResult.state !== "ready" || readyResult.firstSkillToLoad?.id !== "engineering/diagnose") {
+        throw new Error(`Smoke orchestration did not release post-brainstorming workflow after approval: ${readyText}`);
     }
-    if (readyResult.finalWorkflow?.[0]?.skill?.id !== "productivity/brainstorming") {
-        throw new Error(`Smoke final workflow did not start with brainstorming: ${readyText}`);
+    if (readyResult.finalWorkflow?.some((step) => step.skill?.id === "productivity/brainstorming")) {
+        throw new Error(`Smoke final workflow should not repeat brainstorming after approval: ${readyText}`);
     }
     const memoryReport = await client.callTool({
         name: "kilo_memory_report",

package/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kilo-kit/mcp",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Kilo-Kit MCP server for skill routing, skill loading, and validation.",
   "type": "module",
   "private": true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vodailoc/kilo-kit-mcp",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Kilo-Kit MCP server for adaptive skill routing, skill loading, and validation.",
   "license": "Apache-2.0",
   "author": "Kilo-Kit Team",