@vodailoc/kilo-kit-mcp 1.2.0 → 1.3.1

package/mcp/README.md

@@ -1,6 +1,6 @@
 # 🔌 Kilo-Kit MCP Server
 
-> **Version:** 1.2.0
+> **Version:** 1.3.1
 > **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 |
@@ -26,12 +26,14 @@ Resources:
 |----------|---------|
 | `kilo://skills/index` | Lightweight skill index |
 | `kilo://core/master` | Kilo-Kit master skill |
+| `kilo://rules/c4` | Minimal host-agent operating rules for the C4 workflow |
 | `kilo://skills/{category}/{skill}` | Dynamic skill resource |
 
 Prompts:
 
 | Prompt | Purpose |
 |--------|---------|
+| `kilo-c4-workflow` | Run a request through the C4 gate before substantive implementation |
 | `kilo-select-skill` | Route a request before implementation |
 | `kilo-validate-library` | Run the validation quality gate |
 
@@ -50,8 +52,8 @@ npm run smoke
 Expected verification:
 
 ```text
-Test Files  9 passed
-Tests       22 passed
+Test Files  10 passed
+Tests       28 passed
 MCP smoke check passed.
 ```
 
@@ -74,6 +76,16 @@ Use the published npm package in any MCP-capable client:
 
 The npm package includes the Kilo-Kit skill library, core master file, validator, and built MCP server.
 
+Install the host-agent bootstrap rule in each project where you want C4 to run automatically:
+
+```bash
+npx -y --package=@vodailoc/kilo-kit-mcp kilo-kit-init init --client gemini
+npx -y --package=@vodailoc/kilo-kit-mcp kilo-kit-init init --client codex
+npx -y --package=@vodailoc/kilo-kit-mcp kilo-kit-init init --client claude
+```
+
+Use `--client all` to write `GEMINI.md`, `AGENTS.md`, and `CLAUDE.md` in the target project. Use `--dir <path>` to initialize another project directory.
+
 Route telemetry is in-memory by default. To persist route decisions between server runs, set:
 
 ```bash
@@ -91,7 +103,15 @@ 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.
+
+The released workflow is the primary C4 route, not an exclusive context source. After loading the first C4-selected skill, the agent must still inspect its own available skill list and load any other relevant skills before coding.
+
+Installing the MCP server exposes tools, prompts, resources, and server instructions. It does not force every MCP host to call those tools automatically. If a client does not reliably follow MCP server instructions, use `kilo-kit-init` or add one bootstrap rule to the local agent configuration:
+
+```text
+For substantive project work, call kilo_orchestrate_task before implementation and follow the returned C4 state, workflow, and verificationGate.
+```
 
 ### Codex CLI on Windows
 
@@ -120,8 +140,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.1
+git push origin v1.3.1
 ```
 
 The workflow runs build, typecheck, tests, smoke, skill validation, package dry-run, and then `npm publish --access public --ignore-scripts` through OIDC.
@@ -173,10 +193,12 @@ 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
+→ inspect the agent's internal skill list and load any other relevant skills
 → 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/init.js

@@ -0,0 +1,217 @@
+#!/usr/bin/env node
+import { lstatSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const START_MARKER = "<!-- KILO-KIT:C4:START -->";
+const END_MARKER = "<!-- KILO-KIT:C4:END -->";
+const MAX_BOOTSTRAP_FILE_BYTES = 256 * 1024;
+const CLIENT_FILES = {
+    gemini: {
+        fileName: "GEMINI.md",
+        displayName: "Gemini CLI",
+    },
+    codex: {
+        fileName: "AGENTS.md",
+        displayName: "OpenAI Codex",
+    },
+    claude: {
+        fileName: "CLAUDE.md",
+        displayName: "Claude Code",
+    },
+};
+export function bootstrap(options) {
+    validateTargetDirectory(options.cwd);
+    const targets = resolveTargets(options);
+    return targets.map((target) => writeBootstrapBlock(target));
+}
+function resolveTargets(options) {
+    const clients = options.client === "all" ? Object.keys(CLIENT_FILES) : [options.client];
+    return clients.map((client) => {
+        const config = CLIENT_FILES[client];
+        return {
+            client,
+            filePath: path.resolve(options.cwd, config.fileName),
+            displayName: config.displayName,
+        };
+    });
+}
+function writeBootstrapBlock(target) {
+    assertSafeTarget(target.filePath);
+    const block = buildBootstrapBlock(target);
+    let action = "created";
+    let nextContent = block;
+    try {
+        const current = readFileSync(target.filePath, "utf8");
+        action = "updated";
+        nextContent = replaceOrAppendBlock(current, block);
+    }
+    catch (error) {
+        if (!isNotFoundError(error)) {
+            throw error;
+        }
+    }
+    writeFileAtomic(target.filePath, nextContent);
+    return {
+        client: target.client,
+        filePath: target.filePath,
+        action,
+    };
+}
+function replaceOrAppendBlock(current, block) {
+    const start = current.indexOf(START_MARKER);
+    const end = current.indexOf(END_MARKER);
+    const hasStart = start >= 0;
+    const hasEnd = end >= 0;
+    if (hasStart !== hasEnd || (hasStart && end < start)) {
+        throw new Error(`Refusing to update bootstrap file because the Kilo-Kit marker block is malformed. Fix or remove ${START_MARKER} / ${END_MARKER} manually.`);
+    }
+    if (start >= 0 && end > start) {
+        const afterEnd = end + END_MARKER.length;
+        return `${current.slice(0, start)}${block}${current.slice(afterEnd)}`;
+    }
+    const separator = current.endsWith("\n") ? "\n" : "\n\n";
+    return `${current}${separator}${block}`;
+}
+function buildBootstrapBlock(target) {
+    return `${START_MARKER}
+## Kilo-Kit C4 Workflow
+
+Applies to: ${target.displayName}
+
+For substantive coding, debugging, refactoring, review, publishing, or project-work requests:
+
+1. Call \`kilo_orchestrate_task\` before implementation.
+2. If state is \`brainstorming_required\`, load \`productivity/brainstorming\` with \`kilo_get_skill\`, follow it, and get user approval.
+3. Call \`kilo_orchestrate_task\` again with the same \`sessionId\` and \`brainstormingApproved=true\`.
+4. If state is \`awaiting_memory_confirmation\`, accept or reject memory suggestions before execution.
+5. When state is \`ready\`, load \`firstSkillToLoad\` with \`kilo_get_skill\`.
+6. Also inspect the host agent's own available skill list and load any other relevant skills before coding.
+7. Follow \`finalWorkflow\`.
+8. Satisfy \`verificationGate\` before claiming completion.
+
+For read-only requests, \`kilo_route_intent\` is enough.
+${END_MARKER}
+`;
+}
+function isNotFoundError(error) {
+    return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function validateTargetDirectory(cwd) {
+    let stats;
+    try {
+        stats = statSync(cwd);
+    }
+    catch (error) {
+        if (isNotFoundError(error)) {
+            throw new Error(`Target directory does not exist: ${cwd}`);
+        }
+        throw error;
+    }
+    if (!stats.isDirectory()) {
+        throw new Error(`Target path is not a directory: ${cwd}`);
+    }
+    if (lstatSync(cwd).isSymbolicLink()) {
+        throw new Error(`Refusing to write bootstrap files through a symlinked directory: ${cwd}`);
+    }
+}
+function assertSafeTarget(filePath) {
+    try {
+        const stats = lstatSync(filePath);
+        if (stats.isSymbolicLink()) {
+            throw new Error(`Refusing to update symlinked bootstrap file: ${filePath}`);
+        }
+        if (!stats.isFile()) {
+            throw new Error(`Refusing to update non-file bootstrap target: ${filePath}`);
+        }
+        if (stats.size > MAX_BOOTSTRAP_FILE_BYTES) {
+            throw new Error(`Refusing to update bootstrap file larger than ${MAX_BOOTSTRAP_FILE_BYTES} bytes: ${filePath}`);
+        }
+    }
+    catch (error) {
+        if (!isNotFoundError(error)) {
+            throw error;
+        }
+    }
+}
+function writeFileAtomic(filePath, content) {
+    const dir = path.dirname(filePath);
+    const base = path.basename(filePath);
+    const tempPath = path.join(dir, `.${base}.${process.pid}.${Date.now()}.tmp`);
+    try {
+        writeFileSync(tempPath, content, { encoding: "utf8", flag: "wx", mode: 0o644 });
+        renameSync(tempPath, filePath);
+    }
+    catch (error) {
+        try {
+            unlinkSync(tempPath);
+        }
+        catch {
+            // Best-effort cleanup only.
+        }
+        throw error;
+    }
+}
+function parseArgs(argv) {
+    const command = argv[0];
+    if (command !== "init") {
+        throw new Error(usage());
+    }
+    let client;
+    let cwd = process.cwd();
+    for (let index = 1; index < argv.length; index += 1) {
+        const arg = argv[index];
+        if (arg === "--client") {
+            const value = argv[index + 1];
+            if (!value || !isClient(value)) {
+                throw new Error("Expected --client to be one of: gemini, codex, claude, all.");
+            }
+            client = value;
+            index += 1;
+            continue;
+        }
+        if (arg === "--dir") {
+            const value = argv[index + 1];
+            if (!value) {
+                throw new Error("Expected --dir to receive a path.");
+            }
+            cwd = path.resolve(value);
+            index += 1;
+            continue;
+        }
+        if (arg === "--help" || arg === "-h") {
+            throw new Error(usage());
+        }
+        throw new Error(`Unknown argument: ${arg}\n\n${usage()}`);
+    }
+    return {
+        client: client ?? "all",
+        cwd,
+    };
+}
+function isClient(value) {
+    return value === "gemini" || value === "codex" || value === "claude" || value === "all";
+}
+function usage() {
+    return [
+        "Usage:",
+        "  kilo-kit-init init [--client gemini|codex|claude|all] [--dir <path>]",
+        "",
+        "Examples:",
+        "  kilo-kit-init init --client gemini",
+        "  kilo-kit-init init --client codex --dir /path/to/project",
+        "  kilo-kit-init init --client all",
+    ].join("\n");
+}
+async function main() {
+    const options = parseArgs(process.argv.slice(2));
+    const results = bootstrap(options);
+    for (const result of results) {
+        console.log(`${result.action}: ${result.filePath}`);
+    }
+}
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+    main().catch((error) => {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    });
+}

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,20 +179,23 @@ 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(", ")}.`;
     }
     if (firstSkillToLoad) {
-        return `Load ${firstSkillToLoad.id} with kilo_get_skill, then follow the final workflow.`;
+        return `Load ${firstSkillToLoad.id} with kilo_get_skill, then follow the final workflow. IMPORTANT: Do NOT rely solely on this workflow. You MUST also scan your full internal skill list (in your system prompt) and use view_file to load any other relevant skills before coding.`;
+    }
+    return session.route.nextAction + " IMPORTANT: You MUST also scan your full internal skill list and load any other relevant skills before coding.";
+}
+function executableWorkflow(session) {
+    if (!session.brainstormingApproved) {
+        return session.workflow;
     }
-    return session.route.nextAction;
+    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.1";
 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 = {}) {
@@ -43,11 +43,11 @@ export async function createKiloKitServer(options = {}) {
         name: "kilo-kit",
         version: SERVER_VERSION,
     }, {
-        instructions: "Use kilo_route_intent before selecting a Kilo-Kit workflow skill. Load one selected skill with kilo_get_skill, then follow its instructions. Route telemetry is in-memory by default and only persists when KILO_KIT_WRITE_DECISIONS=true.",
+        instructions: "For substantive coding, debugging, refactoring, review, publishing, or project-work requests, call kilo_orchestrate_task before implementation. If it returns brainstorming_required, load productivity/brainstorming with kilo_get_skill and get user approval before coding. After approval, call kilo_orchestrate_task again with the same sessionId and brainstormingApproved=true. If it returns awaiting_memory_confirmation, accept or reject memory suggestions before execution. When it returns ready, load firstSkillToLoad with kilo_get_skill, inspect any additional relevant skills available in the host agent, follow the finalWorkflow, and satisfy verificationGate before claiming completion. For read-only requests, kilo_route_intent is acceptable. Route telemetry is in-memory by default and only persists when KILO_KIT_WRITE_DECISIONS=true.",
     });
     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 } : {}),
         });
@@ -235,6 +237,18 @@ function registerResources(server, repoRoot, registry) {
             },
         ],
     }));
+    server.registerResource("kilo-c4-operating-rules", "kilo://rules/c4", {
+        title: "Kilo-Kit C4 Operating Rules",
+        description: "Minimal rules a host agent should follow after installing the Kilo-Kit MCP server.",
+        mimeType: "text/markdown",
+    }, async (uri) => ({
+        contents: [
+            {
+                uri: uri.href,
+                text: C4_OPERATING_RULES,
+            },
+        ],
+    }));
     server.registerResource("kilo-skill", new ResourceTemplate("kilo://skills/{category}/{skill}", {
         list: async () => ({
             resources: registry.listSkills().map((skill) => ({
@@ -263,6 +277,23 @@ function registerResources(server, repoRoot, registry) {
     });
 }
 function registerPrompts(server) {
+    server.registerPrompt("kilo-c4-workflow", {
+        title: "Run Request Through C4",
+        description: "Prompt the agent to use the C4 gate before substantive implementation work.",
+        argsSchema: {
+            request: z.string().min(1).max(4000),
+        },
+    }, ({ request }) => ({
+        messages: [
+            {
+                role: "user",
+                content: {
+                    type: "text",
+                    text: `Use the Kilo-Kit C4 workflow for this request. Call kilo_orchestrate_task first. If the state is brainstorming_required, load productivity/brainstorming with kilo_get_skill and get approval before coding. If the state is awaiting_memory_confirmation, resolve the suggestions. When the state is ready, load firstSkillToLoad, inspect any other relevant host-agent skills, follow finalWorkflow, and satisfy verificationGate before completion.\n\nRequest:\n${request}`,
+                },
+            },
+        ],
+    }));
     server.registerPrompt("kilo-select-skill", {
         title: "Select Kilo-Kit Skill",
         description: "Prompt the agent to route the current request through Kilo-Kit before implementation.",
@@ -299,6 +330,21 @@ function registerPrompts(server) {
 function normalizeFormat(format) {
     return format ?? "markdown";
 }
+const C4_OPERATING_RULES = `# Kilo-Kit C4 Operating Rules
+
+For substantive coding, debugging, refactoring, review, publishing, or project-work requests:
+
+1. Call \`kilo_orchestrate_task\` before implementation.
+2. If state is \`brainstorming_required\`, load \`productivity/brainstorming\` with \`kilo_get_skill\`, follow it, and get user approval.
+3. Call \`kilo_orchestrate_task\` again with the same \`sessionId\` and \`brainstormingApproved=true\`.
+4. If state is \`awaiting_memory_confirmation\`, accept or reject memory suggestions before execution.
+5. When state is \`ready\`, load \`firstSkillToLoad\` with \`kilo_get_skill\`.
+6. Also inspect the host agent's own available skill list and load any other relevant skills before coding.
+7. Follow \`finalWorkflow\`.
+8. Satisfy \`verificationGate\` before claiming completion.
+
+For read-only requests, \`kilo_route_intent\` is enough.
+`;
 async function main() {
     const server = await createKiloKitServer();
     const transport = new StdioServerTransport();

package/mcp/dist/smoke.js

@@ -23,6 +23,20 @@ try {
             throw new Error(`Missing expected tool: ${required}`);
         }
     }
+    const prompts = await client.listPrompts();
+    const promptNames = prompts.prompts.map((prompt) => prompt.name);
+    for (const required of ["kilo-c4-workflow", "kilo-select-skill", "kilo-validate-library"]) {
+        if (!promptNames.includes(required)) {
+            throw new Error(`Missing expected prompt: ${required}`);
+        }
+    }
+    const resources = await client.listResources();
+    const resourceUris = resources.resources.map((resource) => resource.uri);
+    for (const required of ["kilo://skills/index", "kilo://core/master", "kilo://rules/c4"]) {
+        if (!resourceUris.includes(required)) {
+            throw new Error(`Missing expected resource: ${required}`);
+        }
+    }
     const route = await client.callTool({
         name: "kilo_route_intent",
         arguments: {
@@ -59,31 +73,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",