@vibecodetown/mcp-server 1.3.1

package/build/mcp/generated/skillpack_file.js

@@ -0,0 +1,102 @@
+import { z } from "zod";
+// ============================================================
+// Context Signal (Shadow Trigger)
+// ============================================================
+export const ContextSignalSchema = z.object({
+    source: z.enum([
+        "user_intent",
+        "project_state",
+        "last_tool_output",
+        "session_history",
+        "file_change"
+    ]).describe("Where to detect the signal"),
+    condition: z.string().min(1).max(500).describe("Condition expression (e.g., 'contains:구현', 'state:NEEDS_DECISION', 'tool_result:FIX')"),
+    weight: z.number().min(0.1).max(10.0).default(1.0).optional().describe("Signal weight for matching score calculation")
+}).strict();
+// ============================================================
+// Shadow Mode (Auto-recommend without auto-execute)
+// ============================================================
+export const ShadowModeSchema = z.object({
+    enabled: z.boolean().describe("Whether shadow trigger is active for this skill"),
+    auto_recommend: z.boolean().default(true).optional().describe("Output recommendation message when triggered"),
+    auto_execute: z.literal(false).optional().describe("NEVER_AUTOSUBMIT: Auto-execution is always forbidden"),
+    priority: z.number().int().min(1).max(100).default(50).optional().describe("Recommendation priority when multiple skills match"),
+    cooldown_minutes: z.number().int().min(0).max(1440).default(30).optional().describe("Minimum minutes between repeated recommendations"),
+    context_signals: z.array(ContextSignalSchema).max(20).optional().describe("Signals from tool outputs or project state that trigger recommendation"),
+    recommend_tone: z.enum(["neutral", "emphatic", "strict"]).default("neutral").optional().describe("Tone of recommendation message")
+}).strict();
+// ============================================================
+// Route Target
+// ============================================================
+export const RouteTargetSchema = z.object({
+    tool: z.enum(["vibe_pm.get_decision", "vibe_pm.repair_plan", "vibe_pm.status", "vibe_pm.inspect_code"]),
+    reason: z.string().min(1).max(500)
+}).strict();
+export const PipelineStepSchema = z.object({
+    id: z.string().regex(/^[a-z0-9][a-z0-9._-]{1,64}$/),
+    tool: z.enum([
+        "vibe_pm.ingress",
+        "vibe_pm.briefing",
+        "vibe_pm.status",
+        "vibe_pm.search_oss",
+        "vibe_pm.zoekt_evidence",
+        "vibe_pm.get_decision",
+        "vibe_pm.submit_decision",
+        "vibe_pm.create_work_order",
+        "vibe_pm.inspect_code",
+        "vibe_pm.repair_plan",
+        "vibe_pm.finalize_work"
+    ]),
+    mode: z.enum(["AUTO", "ASSISTED", "STOP_FOR_USER"]).describe("Execution mode for this step"),
+    required: z.boolean().default(true).optional(),
+    input_template: z.record(z.unknown()).describe("Template for tool input with variable substitution").optional(),
+    notes: z.string().max(2000).optional()
+}).strict();
+export const WorkflowSkillSchema = z.object({
+    id: z.string().regex(/^[a-z0-9][a-z0-9._-]{2,96}$/),
+    version: z.string().regex(/^[0-9]+\.[0-9]+\.[0-9]+$/),
+    title: z.string().min(1).max(120),
+    intent: z.string().min(1).max(2000),
+    shadow_mode: ShadowModeSchema.optional().describe("Shadow trigger configuration for auto-recommendation"),
+    triggers: z.object({
+        keywords_any: z.array(z.string()).max(30).optional(),
+        keywords_all: z.array(z.string()).max(30).optional(),
+        project_state_any: z.array(z.enum([
+            "NOT_INITIALIZED",
+            "NEEDS_INGRESS",
+            "NEEDS_DECISION",
+            "READY_FOR_WORK_ORDER",
+            "IMPLEMENTING",
+            "NEEDS_INSPECTION",
+            "READY_TO_FINALIZE"
+        ])).max(12).optional(),
+        missing_signals_any: z.array(z.string()).max(20).describe("Detect missing fields for beginner users").optional()
+    }).strict(),
+    pipeline: z.array(PipelineStepSchema).min(1).max(30),
+    interaction_policy: z.object({
+        decision_submission: z.literal("NEVER_AUTOSUBMIT").describe("Decision submission automation is forbidden"),
+        stop_points: z.array(z.enum(["AFTER_GET_DECISION", "AFTER_PROPOSAL", "BEFORE_FINALIZE"])).min(1).describe("Points where user input is mandatory")
+    }).strict(),
+    routing: z.object({
+        on_fix: RouteTargetSchema.optional(),
+        on_block: RouteTargetSchema.optional(),
+        on_error: RouteTargetSchema.optional()
+    }).strict().optional(),
+    outputs: z.object({
+        execution_log_path_template: z.string().min(1).describe("Template path for execution evidence storage"),
+        evidence_paths: z.array(z.string()).max(20).optional()
+    }).strict()
+}).strict();
+export const SkillPackMetaSchema = z.object({
+    id: z.string().regex(/^[a-z0-9][a-z0-9._-]{2,64}$/),
+    version: z.string().regex(/^[0-9]+\.[0-9]+\.[0-9]+$/),
+    fingerprint: z.string().min(8).max(128),
+    title: z.string().min(1).max(120),
+    description: z.string().min(1).max(2000),
+    tags: z.array(z.string()).max(32).optional()
+}).strict();
+export const SkillPackFileSchema = z.object({
+    schema_version: z.enum(["1.0.0", "1.1.0"]).describe("Schema version (1.1.0 adds shadow_mode)"),
+    pack: SkillPackMetaSchema,
+    skills: z.array(WorkflowSkillSchema).min(1).max(50)
+}).strict().describe("SSOT schema for skillpack.json file");

package/build/mcp/generated/skills_input.d.ts

@@ -0,0 +1,30 @@
+import { z } from "zod";
+export declare const SkillsInputSchema: z.ZodObject<{
+    action: z.ZodEnum<["recommend", "execute", "status", "list"]>;
+    project_id: z.ZodOptional<z.ZodString>;
+    run_id: z.ZodOptional<z.ZodString>;
+    skill_id: z.ZodOptional<z.ZodString>;
+    user_intent: z.ZodOptional<z.ZodString>;
+    step_input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    resume_from: z.ZodOptional<z.ZodString>;
+    max_recommendations: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+}, "strict", z.ZodTypeAny, {
+    action: "status" | "list" | "recommend" | "execute";
+    run_id?: string | undefined;
+    project_id?: string | undefined;
+    skill_id?: string | undefined;
+    user_intent?: string | undefined;
+    step_input?: Record<string, unknown> | undefined;
+    resume_from?: string | undefined;
+    max_recommendations?: number | undefined;
+}, {
+    action: "status" | "list" | "recommend" | "execute";
+    run_id?: string | undefined;
+    project_id?: string | undefined;
+    skill_id?: string | undefined;
+    user_intent?: string | undefined;
+    step_input?: Record<string, unknown> | undefined;
+    resume_from?: string | undefined;
+    max_recommendations?: number | undefined;
+}>;
+export type SkillsInput = z.infer<typeof SkillsInputSchema>;

package/build/mcp/generated/skills_input.js

@@ -0,0 +1,11 @@
+import { z } from "zod";
+export const SkillsInputSchema = z.object({
+    action: z.enum(["recommend", "execute", "status", "list"]).describe("Action to perform"),
+    project_id: z.string().min(1).describe("Project ID (uses current folder if omitted)").optional(),
+    run_id: z.string().min(1).describe("Run ID (takes precedence over project_id)").optional(),
+    skill_id: z.string().regex(/^[a-z0-9][a-z0-9._-]{2,96}$/).describe("[execute only] Skill ID to execute").optional(),
+    user_intent: z.string().min(1).max(4000).describe("[recommend only] User intent in natural language").optional(),
+    step_input: z.record(z.unknown()).describe("[execute only] User input for current step").optional(),
+    resume_from: z.string().min(1).describe("[execute only] Execution ID to resume from").optional(),
+    max_recommendations: z.number().int().min(1).max(10).default(3).describe("[recommend only] Maximum number of recommendations").optional()
+}).strict().describe("SSOT schema for vibe_pm.skills MCP tool input");

package/build/mcp/generated/skills_output.d.ts

@@ -0,0 +1,349 @@
+import { z } from "zod";
+export declare const SkillRecommendationSchema: z.ZodObject<{
+    skill_id: z.ZodString;
+    title: z.ZodString;
+    intent: z.ZodOptional<z.ZodString>;
+    match_score: z.ZodNumber;
+    match_reasons: z.ZodArray<z.ZodString, "many">;
+}, "strict", z.ZodTypeAny, {
+    title: string;
+    skill_id: string;
+    match_score: number;
+    match_reasons: string[];
+    intent?: string | undefined;
+}, {
+    title: string;
+    skill_id: string;
+    match_score: number;
+    match_reasons: string[];
+    intent?: string | undefined;
+}>;
+export declare const SkillExecutionSchema: z.ZodObject<{
+    execution_id: z.ZodString;
+    skill_id: z.ZodString;
+    status: z.ZodEnum<["running", "waiting_for_user", "completed", "failed", "aborted"]>;
+    current_step: z.ZodOptional<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        tool: z.ZodOptional<z.ZodString>;
+        mode: z.ZodOptional<z.ZodString>;
+        result: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        id: z.ZodOptional<z.ZodString>;
+        tool: z.ZodOptional<z.ZodString>;
+        mode: z.ZodOptional<z.ZodString>;
+        result: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        id: z.ZodOptional<z.ZodString>;
+        tool: z.ZodOptional<z.ZodString>;
+        mode: z.ZodOptional<z.ZodString>;
+        result: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.ZodTypeAny, "passthrough">>>;
+    completed_steps: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    pending_steps: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    user_prompt: z.ZodOptional<z.ZodString>;
+    next_action: z.ZodOptional<z.ZodString>;
+    execution_log_path: z.ZodOptional<z.ZodString>;
+    evidence_paths: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strict", z.ZodTypeAny, {
+    status: "running" | "completed" | "failed" | "aborted" | "waiting_for_user";
+    skill_id: string;
+    execution_id: string;
+    next_action?: string | undefined;
+    current_step?: z.objectOutputType<{
+        id: z.ZodOptional<z.ZodString>;
+        tool: z.ZodOptional<z.ZodString>;
+        mode: z.ZodOptional<z.ZodString>;
+        result: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+    completed_steps?: string[] | undefined;
+    pending_steps?: string[] | undefined;
+    user_prompt?: string | undefined;
+    execution_log_path?: string | undefined;
+    evidence_paths?: string[] | undefined;
+}, {
+    status: "running" | "completed" | "failed" | "aborted" | "waiting_for_user";
+    skill_id: string;
+    execution_id: string;
+    next_action?: string | undefined;
+    current_step?: z.objectInputType<{
+        id: z.ZodOptional<z.ZodString>;
+        tool: z.ZodOptional<z.ZodString>;
+        mode: z.ZodOptional<z.ZodString>;
+        result: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+    completed_steps?: string[] | undefined;
+    pending_steps?: string[] | undefined;
+    user_prompt?: string | undefined;
+    execution_log_path?: string | undefined;
+    evidence_paths?: string[] | undefined;
+}>;
+export declare const SkillSummarySchema: z.ZodObject<{
+    skill_id: z.ZodString;
+    title: z.ZodString;
+    intent: z.ZodOptional<z.ZodString>;
+    pack_id: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    title: string;
+    skill_id: string;
+    pack_id: string;
+    version?: string | undefined;
+    intent?: string | undefined;
+}, {
+    title: string;
+    skill_id: string;
+    pack_id: string;
+    version?: string | undefined;
+    intent?: string | undefined;
+}>;
+export declare const ExecutionStatusSchema: z.ZodObject<{
+    execution_id: z.ZodString;
+    skill_id: z.ZodString;
+    status: z.ZodEnum<["running", "waiting_for_user", "completed", "failed", "aborted"]>;
+    current_step_id: z.ZodOptional<z.ZodString>;
+    progress: z.ZodOptional<z.ZodNumber>;
+    started_at: z.ZodOptional<z.ZodString>;
+    updated_at: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    status: "running" | "completed" | "failed" | "aborted" | "waiting_for_user";
+    skill_id: string;
+    execution_id: string;
+    updated_at?: string | undefined;
+    started_at?: string | undefined;
+    current_step_id?: string | undefined;
+    progress?: number | undefined;
+}, {
+    status: "running" | "completed" | "failed" | "aborted" | "waiting_for_user";
+    skill_id: string;
+    execution_id: string;
+    updated_at?: string | undefined;
+    started_at?: string | undefined;
+    current_step_id?: string | undefined;
+    progress?: number | undefined;
+}>;
+export declare const SkillsOutputSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+    action: z.ZodEnum<["recommend", "execute", "status", "list"]>;
+    error: z.ZodOptional<z.ZodString>;
+    error_code: z.ZodOptional<z.ZodString>;
+    hint: z.ZodOptional<z.ZodString>;
+    recommendations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        skill_id: z.ZodString;
+        title: z.ZodString;
+        intent: z.ZodOptional<z.ZodString>;
+        match_score: z.ZodNumber;
+        match_reasons: z.ZodArray<z.ZodString, "many">;
+    }, "strict", z.ZodTypeAny, {
+        title: string;
+        skill_id: string;
+        match_score: number;
+        match_reasons: string[];
+        intent?: string | undefined;
+    }, {
+        title: string;
+        skill_id: string;
+        match_score: number;
+        match_reasons: string[];
+        intent?: string | undefined;
+    }>, "many">>;
+    execution: z.ZodOptional<z.ZodObject<{
+        execution_id: z.ZodString;
+        skill_id: z.ZodString;
+        status: z.ZodEnum<["running", "waiting_for_user", "completed", "failed", "aborted"]>;
+        current_step: z.ZodOptional<z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            tool: z.ZodOptional<z.ZodString>;
+            mode: z.ZodOptional<z.ZodString>;
+            result: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            id: z.ZodOptional<z.ZodString>;
+            tool: z.ZodOptional<z.ZodString>;
+            mode: z.ZodOptional<z.ZodString>;
+            result: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            id: z.ZodOptional<z.ZodString>;
+            tool: z.ZodOptional<z.ZodString>;
+            mode: z.ZodOptional<z.ZodString>;
+            result: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.ZodTypeAny, "passthrough">>>;
+        completed_steps: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        pending_steps: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        user_prompt: z.ZodOptional<z.ZodString>;
+        next_action: z.ZodOptional<z.ZodString>;
+        execution_log_path: z.ZodOptional<z.ZodString>;
+        evidence_paths: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strict", z.ZodTypeAny, {
+        status: "running" | "completed" | "failed" | "aborted" | "waiting_for_user";
+        skill_id: string;
+        execution_id: string;
+        next_action?: string | undefined;
+        current_step?: z.objectOutputType<{
+            id: z.ZodOptional<z.ZodString>;
+            tool: z.ZodOptional<z.ZodString>;
+            mode: z.ZodOptional<z.ZodString>;
+            result: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.ZodTypeAny, "passthrough"> | undefined;
+        completed_steps?: string[] | undefined;
+        pending_steps?: string[] | undefined;
+        user_prompt?: string | undefined;
+        execution_log_path?: string | undefined;
+        evidence_paths?: string[] | undefined;
+    }, {
+        status: "running" | "completed" | "failed" | "aborted" | "waiting_for_user";
+        skill_id: string;
+        execution_id: string;
+        next_action?: string | undefined;
+        current_step?: z.objectInputType<{
+            id: z.ZodOptional<z.ZodString>;
+            tool: z.ZodOptional<z.ZodString>;
+            mode: z.ZodOptional<z.ZodString>;
+            result: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.ZodTypeAny, "passthrough"> | undefined;
+        completed_steps?: string[] | undefined;
+        pending_steps?: string[] | undefined;
+        user_prompt?: string | undefined;
+        execution_log_path?: string | undefined;
+        evidence_paths?: string[] | undefined;
+    }>>;
+    available_skills: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        skill_id: z.ZodString;
+        title: z.ZodString;
+        intent: z.ZodOptional<z.ZodString>;
+        pack_id: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        title: string;
+        skill_id: string;
+        pack_id: string;
+        version?: string | undefined;
+        intent?: string | undefined;
+    }, {
+        title: string;
+        skill_id: string;
+        pack_id: string;
+        version?: string | undefined;
+        intent?: string | undefined;
+    }>, "many">>;
+    execution_status: z.ZodOptional<z.ZodObject<{
+        execution_id: z.ZodString;
+        skill_id: z.ZodString;
+        status: z.ZodEnum<["running", "waiting_for_user", "completed", "failed", "aborted"]>;
+        current_step_id: z.ZodOptional<z.ZodString>;
+        progress: z.ZodOptional<z.ZodNumber>;
+        started_at: z.ZodOptional<z.ZodString>;
+        updated_at: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        status: "running" | "completed" | "failed" | "aborted" | "waiting_for_user";
+        skill_id: string;
+        execution_id: string;
+        updated_at?: string | undefined;
+        started_at?: string | undefined;
+        current_step_id?: string | undefined;
+        progress?: number | undefined;
+    }, {
+        status: "running" | "completed" | "failed" | "aborted" | "waiting_for_user";
+        skill_id: string;
+        execution_id: string;
+        updated_at?: string | undefined;
+        started_at?: string | undefined;
+        current_step_id?: string | undefined;
+        progress?: number | undefined;
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    ok: boolean;
+    action: "status" | "list" | "recommend" | "execute";
+    error?: string | undefined;
+    error_code?: string | undefined;
+    hint?: string | undefined;
+    recommendations?: {
+        title: string;
+        skill_id: string;
+        match_score: number;
+        match_reasons: string[];
+        intent?: string | undefined;
+    }[] | undefined;
+    execution?: {
+        status: "running" | "completed" | "failed" | "aborted" | "waiting_for_user";
+        skill_id: string;
+        execution_id: string;
+        next_action?: string | undefined;
+        current_step?: z.objectOutputType<{
+            id: z.ZodOptional<z.ZodString>;
+            tool: z.ZodOptional<z.ZodString>;
+            mode: z.ZodOptional<z.ZodString>;
+            result: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.ZodTypeAny, "passthrough"> | undefined;
+        completed_steps?: string[] | undefined;
+        pending_steps?: string[] | undefined;
+        user_prompt?: string | undefined;
+        execution_log_path?: string | undefined;
+        evidence_paths?: string[] | undefined;
+    } | undefined;
+    available_skills?: {
+        title: string;
+        skill_id: string;
+        pack_id: string;
+        version?: string | undefined;
+        intent?: string | undefined;
+    }[] | undefined;
+    execution_status?: {
+        status: "running" | "completed" | "failed" | "aborted" | "waiting_for_user";
+        skill_id: string;
+        execution_id: string;
+        updated_at?: string | undefined;
+        started_at?: string | undefined;
+        current_step_id?: string | undefined;
+        progress?: number | undefined;
+    } | undefined;
+}, {
+    ok: boolean;
+    action: "status" | "list" | "recommend" | "execute";
+    error?: string | undefined;
+    error_code?: string | undefined;
+    hint?: string | undefined;
+    recommendations?: {
+        title: string;
+        skill_id: string;
+        match_score: number;
+        match_reasons: string[];
+        intent?: string | undefined;
+    }[] | undefined;
+    execution?: {
+        status: "running" | "completed" | "failed" | "aborted" | "waiting_for_user";
+        skill_id: string;
+        execution_id: string;
+        next_action?: string | undefined;
+        current_step?: z.objectInputType<{
+            id: z.ZodOptional<z.ZodString>;
+            tool: z.ZodOptional<z.ZodString>;
+            mode: z.ZodOptional<z.ZodString>;
+            result: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.ZodTypeAny, "passthrough"> | undefined;
+        completed_steps?: string[] | undefined;
+        pending_steps?: string[] | undefined;
+        user_prompt?: string | undefined;
+        execution_log_path?: string | undefined;
+        evidence_paths?: string[] | undefined;
+    } | undefined;
+    available_skills?: {
+        title: string;
+        skill_id: string;
+        pack_id: string;
+        version?: string | undefined;
+        intent?: string | undefined;
+    }[] | undefined;
+    execution_status?: {
+        status: "running" | "completed" | "failed" | "aborted" | "waiting_for_user";
+        skill_id: string;
+        execution_id: string;
+        updated_at?: string | undefined;
+        started_at?: string | undefined;
+        current_step_id?: string | undefined;
+        progress?: number | undefined;
+    } | undefined;
+}>;
+export type SkillRecommendation = z.infer<typeof SkillRecommendationSchema>;
+export type SkillExecution = z.infer<typeof SkillExecutionSchema>;
+export type SkillSummary = z.infer<typeof SkillSummarySchema>;
+export type ExecutionStatus = z.infer<typeof ExecutionStatusSchema>;
+export type SkillsOutput = z.infer<typeof SkillsOutputSchema>;

package/build/mcp/generated/skills_output.js

@@ -0,0 +1,52 @@
+import { z } from "zod";
+export const SkillRecommendationSchema = z.object({
+    skill_id: z.string(),
+    title: z.string(),
+    intent: z.string().optional(),
+    match_score: z.number().min(0).max(1).describe("Match score (0.0 ~ 1.0)"),
+    match_reasons: z.array(z.string()).describe("Reasons for the match")
+}).strict();
+export const SkillExecutionSchema = z.object({
+    execution_id: z.string(),
+    skill_id: z.string(),
+    status: z.enum(["running", "waiting_for_user", "completed", "failed", "aborted"]),
+    current_step: z.object({
+        id: z.string().optional(),
+        tool: z.string().optional(),
+        mode: z.string().optional(),
+        result: z.record(z.unknown()).optional()
+    }).passthrough().optional(),
+    completed_steps: z.array(z.string()).optional(),
+    pending_steps: z.array(z.string()).optional(),
+    user_prompt: z.string().describe("Prompt to display when user input is needed").optional(),
+    next_action: z.string().describe("Guidance for next action").optional(),
+    execution_log_path: z.string().optional(),
+    evidence_paths: z.array(z.string()).optional()
+}).strict();
+export const SkillSummarySchema = z.object({
+    skill_id: z.string(),
+    title: z.string(),
+    intent: z.string().optional(),
+    pack_id: z.string(),
+    version: z.string().optional()
+}).strict();
+export const ExecutionStatusSchema = z.object({
+    execution_id: z.string(),
+    skill_id: z.string(),
+    status: z.enum(["running", "waiting_for_user", "completed", "failed", "aborted"]),
+    current_step_id: z.string().optional(),
+    progress: z.number().int().min(0).max(100).describe("Progress percentage (0 ~ 100)").optional(),
+    started_at: z.string().datetime().optional(),
+    updated_at: z.string().datetime().optional()
+}).strict();
+export const SkillsOutputSchema = z.object({
+    ok: z.boolean(),
+    action: z.enum(["recommend", "execute", "status", "list"]),
+    error: z.string().optional(),
+    error_code: z.string().optional(),
+    hint: z.string().optional(),
+    recommendations: z.array(SkillRecommendationSchema).describe("[recommend] Recommended skills list").optional(),
+    execution: SkillExecutionSchema.describe("[execute] Execution result").optional(),
+    available_skills: z.array(SkillSummarySchema).describe("[list] Available skills list").optional(),
+    execution_status: ExecutionStatusSchema.describe("[status] Current execution status").optional()
+}).strict().describe("SSOT schema for vibe_pm.skills MCP tool output");