@cubis/foundry 0.3.63 → 0.3.64

package/mcp/src/tools/skillTools.test.ts

@@ -1,13 +1,23 @@
 import { describe, expect, it } from "vitest";
-import { mkdirSync, mkdtempSync, statSync, writeFileSync } from "node:fs";
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
 import type { VaultManifest } from "../vault/types.js";
+import type { RouteManifest } from "../routes/types.js";
 import { handleSkillBrowseCategory } from "./skillBrowseCategory.js";
 import { handleSkillBudgetReport } from "./skillBudgetReport.js";
 import { handleSkillGet } from "./skillGet.js";
 import { handleSkillGetReference } from "./skillGetReference.js";
 import { handleSkillListCategories } from "./skillListCategories.js";
+import { handleRouteResolve } from "./routeResolve.js";
 import { handleSkillSearch } from "./skillSearch.js";
 import { handleSkillValidate } from "./skillValidate.js";
 
@@ -16,7 +26,11 @@ function payload(result: { content: Array<{ text: string }> }): Record<string, u
 }
 
 function metrics(result: { structuredContent?: Record<string, unknown> }): Record<string, unknown> {
-  return (result.structuredContent?.metrics || {}) as Record<string, unknown>;
+  return (
+    result.structuredContent?.metrics ||
+    (result as { _meta?: { metrics?: Record<string, unknown> } })._meta?.metrics ||
+    {}
+  ) as Record<string, unknown>;
 }
 
 function createSkillFile(id: string, description: string, body = "# Content"): string {
@@ -64,6 +78,229 @@ function createManifest(): VaultManifest {
   };
 }
 
+function createRouteManifest(): RouteManifest {
+  return {
+    $schema: "cubis-foundry-route-manifest-v1",
+    generatedAt: new Date(0).toISOString(),
+    contentHash: "test",
+    summary: { totalRoutes: 6, workflows: 5, agents: 1 },
+    routes: [
+      {
+        kind: "workflow",
+        id: "create",
+        command: "/create",
+        displayName: "Create Workflow",
+        description: "Implement feature work with minimal blast radius",
+        triggers: ["create", "build", "implement", "feature"],
+        primaryAgent: "orchestrator",
+        supportingAgents: ["backend-specialist", "frontend-specialist"],
+        primarySkills: ["feature-forge", "architecture-designer"],
+        supportingSkills: ["lint-and-validate", "test-master"],
+        artifacts: {
+          codex: { compatibilityAlias: "$workflow-create", workflowFile: "create.md" },
+          copilot: { workflowFile: "create.md", promptFile: "workflow-create.prompt.md" },
+          antigravity: { workflowFile: "create.md", commandFile: "create.toml" },
+        },
+      },
+      {
+        kind: "workflow",
+        id: "mobile",
+        command: "/mobile",
+        displayName: "Mobile Workflow",
+        description: "Drive mobile implementation decisions",
+        triggers: ["mobile", "flutter", "ios", "android"],
+        primaryAgent: "mobile-developer",
+        supportingAgents: ["frontend-specialist", "test-engineer"],
+        primarySkills: ["mobile-design", "flutter-expert"],
+        supportingSkills: ["riverpod-3"],
+        artifacts: {
+          codex: { compatibilityAlias: "$workflow-mobile", workflowFile: "mobile.md" },
+          copilot: { workflowFile: "mobile.md", promptFile: "workflow-mobile.prompt.md" },
+          antigravity: { workflowFile: "mobile.md", commandFile: "mobile.toml" },
+        },
+      },
+      {
+        kind: "workflow",
+        id: "review",
+        command: "/review",
+        displayName: "Review Workflow",
+        description: "Run a strict review for bugs and regressions",
+        triggers: ["review", "audit", "bugs"],
+        primaryAgent: "orchestrator",
+        supportingAgents: ["security-auditor"],
+        primarySkills: ["find-bugs"],
+        supportingSkills: ["security-reviewer"],
+        artifacts: {
+          codex: { compatibilityAlias: "$workflow-review", workflowFile: "review.md" },
+          copilot: { workflowFile: "review.md", promptFile: "workflow-review.prompt.md" },
+          antigravity: { workflowFile: "review.md", commandFile: "review.toml" },
+        },
+      },
+      {
+        kind: "workflow",
+        id: "plan",
+        command: "/plan",
+        displayName: "Plan Workflow",
+        description: "Build a decision-complete implementation plan",
+        triggers: ["plan", "spec", "design"],
+        primaryAgent: "project-planner",
+        supportingAgents: ["product-manager", "test-engineer"],
+        primarySkills: ["plan-writing", "architecture-designer"],
+        supportingSkills: ["feature-forge", "api-designer"],
+        artifacts: {
+          codex: { compatibilityAlias: "$workflow-plan", workflowFile: "plan.md" },
+          copilot: { workflowFile: "plan.md", promptFile: "workflow-plan.prompt.md" },
+          antigravity: { workflowFile: "plan.md", commandFile: "plan.toml" },
+        },
+      },
+      {
+        kind: "workflow",
+        id: "orchestrate",
+        command: "/orchestrate",
+        displayName: "Orchestrate Workflow",
+        description: "Coordinate multiple specialists for cross-cutting work",
+        triggers: ["orchestrate", "coordinate", "cross-team"],
+        primaryAgent: "orchestrator",
+        supportingAgents: ["backend-specialist", "database-architect"],
+        primarySkills: ["parallel-agents", "architecture-designer"],
+        supportingSkills: ["plan-writing", "feature-forge"],
+        artifacts: {
+          codex: { compatibilityAlias: "$workflow-orchestrate", workflowFile: "orchestrate.md" },
+          copilot: { workflowFile: "orchestrate.md", promptFile: "workflow-orchestrate.prompt.md" },
+          antigravity: { workflowFile: "orchestrate.md", commandFile: "orchestrate.toml" },
+        },
+      },
+      {
+        kind: "agent",
+        id: "mobile-developer",
+        command: null,
+        displayName: "mobile-developer",
+        description: "Expert in Flutter and mobile app development",
+        triggers: ["mobile", "flutter", "ios", "android"],
+        primaryAgent: "mobile-developer",
+        supportingAgents: [],
+        primarySkills: ["mobile-design", "flutter-expert"],
+        supportingSkills: ["flutter-test-master"],
+        artifacts: {
+          codex: { compatibilityAlias: "$agent-mobile-developer", agentFile: "mobile-developer.md" },
+          copilot: { agentFile: "mobile-developer.md" },
+          antigravity: { agentFile: "mobile-developer.md" },
+        },
+      },
+    ],
+  };
+}
+
+const REPO_ROOT = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  "../../..",
+);
+const GENERATED_MANIFEST_PATH = path.join(
+  REPO_ROOT,
+  "mcp/generated/mcp-manifest.json",
+);
+const SKILLS_ROOT = path.join(REPO_ROOT, "workflows", "skills");
+
+interface GeneratedSkillManifest {
+  fullCatalogEstimatedTokens?: number;
+  skills: Array<{
+    id: string;
+    category: string;
+    description?: string;
+    fileBytes: number;
+    metadata?: Record<string, string>;
+  }>;
+}
+
+function loadGeneratedCatalog(): {
+  generated: GeneratedSkillManifest;
+  runtimeManifest: VaultManifest;
+} {
+  const generated = JSON.parse(
+    readFileSync(GENERATED_MANIFEST_PATH, "utf8"),
+  ) as GeneratedSkillManifest;
+  const runtimeManifest: VaultManifest = {
+    categories: [...new Set(generated.skills.map((skill) => skill.category))].sort(),
+    skills: generated.skills.map((skill) => ({
+      id: skill.id,
+      category: skill.category,
+      description: skill.description,
+      fileBytes: skill.fileBytes,
+      path: path.join(SKILLS_ROOT, skill.id, "SKILL.md"),
+    })),
+    fullCatalogBytes: generated.skills.reduce(
+      (sum, skill) => sum + skill.fileBytes,
+      0,
+    ),
+    fullCatalogEstimatedTokens:
+      generated.fullCatalogEstimatedTokens ??
+      Math.ceil(
+        generated.skills.reduce((sum, skill) => sum + skill.fileBytes, 0) / 4,
+      ),
+  };
+
+  return { generated, runtimeManifest };
+}
+
+const GENERIC_QUERY_WORDS = new Set([
+  "alias",
+  "architect",
+  "architecture",
+  "best",
+  "builder",
+  "checklist",
+  "compatibility",
+  "coordinator",
+  "decision",
+  "deprecated",
+  "design",
+  "developer",
+  "engineer",
+  "expert",
+  "flow",
+  "framework",
+  "fundamentals",
+  "guide",
+  "guidance",
+  "implementation",
+  "manager",
+  "mobile",
+  "patterns",
+  "practices",
+  "pro",
+  "protocol",
+  "reviewer",
+  "skill",
+  "specialist",
+  "system",
+  "test",
+  "testing",
+  "workflow",
+]);
+
+function normalizeTokens(value: string): string[] {
+  return value
+    .toLowerCase()
+    .split(/[^a-z0-9]+/)
+    .filter((token) => token.length >= 3);
+}
+
+function buildDiscoveryQuery(skill: {
+  id: string;
+  category: string;
+  description?: string;
+}): string {
+  const idTokens = normalizeTokens(skill.id).filter(
+    (token) => !GENERIC_QUERY_WORDS.has(token),
+  );
+  const descriptionTokens = normalizeTokens(skill.description ?? "").filter(
+    (token) => !GENERIC_QUERY_WORDS.has(token),
+  );
+  const merged = [...new Set([...idTokens, ...descriptionTokens])];
+  const seedTokens = merged.slice(0, 3);
+  return [skill.category, ...seedTokens].filter(Boolean).join(" ");
+}
+
 describe("skill tools", () => {
   it("lists categories with skill counts", () => {
     const manifest = createManifest();
@@ -139,6 +376,231 @@ describe("skill tools", () => {
     ]);
   });
 
+  it("returns ranked partial matches for natural-language queries", async () => {
+    const flutterFile = createSkillFile(
+      "flutter-expert",
+      "Flutter app architecture coordinator for mobile apps",
+    );
+    const apiFile = createSkillFile(
+      "api-patterns",
+      "API design principles and decision-making",
+    );
+    const flutterBytes = statSync(flutterFile).size;
+    const apiBytes = statSync(apiFile).size;
+    const manifest: VaultManifest = {
+      categories: ["api", "mobile"],
+      skills: [
+        {
+          id: "flutter-expert",
+          category: "mobile",
+          path: flutterFile,
+          fileBytes: flutterBytes,
+        },
+        {
+          id: "api-patterns",
+          category: "api",
+          path: apiFile,
+          fileBytes: apiBytes,
+        },
+      ],
+      fullCatalogBytes: flutterBytes + apiBytes,
+      fullCatalogEstimatedTokens: Math.ceil((flutterBytes + apiBytes) / 4),
+    };
+
+    const result = payload(
+      await handleSkillSearch(
+        { query: "flutter dio auth headers branch multi-tenant api" },
+        manifest,
+        200,
+        4,
+      ),
+    );
+
+    expect(result.count).toBeGreaterThan(0);
+    expect(result.results).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ id: "flutter-expert" }),
+      ]),
+    );
+  });
+
+  it("resolves an explicit workflow command before skill discovery", async () => {
+    const result = payload(
+      await handleRouteResolve({ intent: "/mobile" }, createRouteManifest()),
+    );
+    expect(result).toMatchObject({
+      resolved: true,
+      kind: "workflow",
+      id: "mobile",
+      agent: "mobile-developer",
+      matchedBy: "explicit-workflow-command",
+    });
+  });
+
+  it("resolves an explicit custom agent mention before skill discovery", async () => {
+    const result = payload(
+      await handleRouteResolve(
+        { intent: "@mobile-developer" },
+        createRouteManifest(),
+      ),
+    );
+    expect(result).toMatchObject({
+      resolved: true,
+      kind: "agent",
+      id: "mobile-developer",
+      matchedBy: "explicit-agent",
+    });
+  });
+
+  it("resolves free-text trigger intent to a workflow route", async () => {
+    const result = payload(
+      await handleRouteResolve(
+        { intent: "fix flutter navigation and mobile behavior" },
+        createRouteManifest(),
+      ),
+    );
+    expect(result).toMatchObject({
+      resolved: true,
+      kind: "workflow",
+      id: "mobile",
+    });
+    expect(["trigger-match", "intent-match"]).toContain(result.matchedBy);
+  });
+
+  it("routes skill authoring intent to create with skill-authoring as the primary skill hint", async () => {
+    const result = payload(
+      await handleRouteResolve(
+        { intent: "create a new skill package for Copilot and Codex" },
+        createRouteManifest(),
+      ),
+    );
+    expect(result).toMatchObject({
+      resolved: true,
+      kind: "workflow",
+      id: "create",
+      primarySkillHint: "skill-authoring",
+      matchedBy: "skill-authoring-intent",
+    });
+  });
+
+  it("routes skill planning intent to plan with skill-authoring as the primary skill hint", async () => {
+    const result = payload(
+      await handleRouteResolve(
+        { intent: "plan a new skill and its sidecar references" },
+        createRouteManifest(),
+      ),
+    );
+    expect(result).toMatchObject({
+      resolved: true,
+      kind: "workflow",
+      id: "plan",
+      primarySkillHint: "skill-authoring",
+      matchedBy: "skill-authoring-intent",
+    });
+  });
+
+  it("routes skill review intent to review with skill-authoring as the primary skill hint", async () => {
+    const result = payload(
+      await handleRouteResolve(
+        { intent: "review this skill metadata and broken references" },
+        createRouteManifest(),
+      ),
+    );
+    expect(result).toMatchObject({
+      resolved: true,
+      kind: "workflow",
+      id: "review",
+      primarySkillHint: "skill-authoring",
+      matchedBy: "skill-authoring-intent",
+    });
+  });
+
+  it("falls back cleanly when no route matches the intent", async () => {
+    const result = payload(
+      await handleRouteResolve(
+        { intent: "obscure domain with no known route" },
+        createRouteManifest(),
+      ),
+    );
+    expect(result).toMatchObject({
+      resolved: false,
+      fallbackSkillSearchRecommended: true,
+      matchedBy: "none",
+    });
+  });
+
+  it("adds a repo-signal language skill hint when TypeScript signals exist", async () => {
+    const originalCwd = process.cwd();
+    const tempDir = mkdtempSync(path.join(os.tmpdir(), "route-resolve-ts-"));
+    writeFileSync(path.join(tempDir, "package.json"), '{"name":"tmp"}\n', "utf8");
+    writeFileSync(path.join(tempDir, "tsconfig.json"), '{"compilerOptions":{"strict":true}}\n', "utf8");
+    process.chdir(tempDir);
+
+    try {
+      const result = payload(
+        await handleRouteResolve(
+          { intent: "build a backend api" },
+          createRouteManifest(),
+        ),
+      );
+      expect(result.detectedLanguageSkill).toBe("typescript-pro");
+    } finally {
+      process.chdir(originalCwd);
+    }
+  });
+
+  it("finds every generated skill by exact id", async () => {
+    const { runtimeManifest } = loadGeneratedCatalog();
+    const missing: string[] = [];
+
+    for (const skill of runtimeManifest.skills) {
+      const result = payload(
+        await handleSkillSearch({ query: skill.id }, runtimeManifest, 200, 4),
+      );
+      const ids = (result.results as Array<{ id: string }>).map((item) => item.id);
+      if (!ids.includes(skill.id)) {
+        missing.push(skill.id);
+      }
+    }
+
+    expect(missing).toEqual([]);
+  });
+
+  it("finds at least one skill in every generated category", async () => {
+    const { runtimeManifest } = loadGeneratedCatalog();
+    const missingCategories: string[] = [];
+
+    for (const category of runtimeManifest.categories) {
+      const result = payload(
+        await handleSkillSearch({ query: category }, runtimeManifest, 200, 4),
+      );
+      const results = result.results as Array<{ category: string }>;
+      if (!results.some((item) => item.category === category)) {
+        missingCategories.push(category);
+      }
+    }
+
+    expect(missingCategories).toEqual([]);
+  });
+
+  it("finds every generated skill through a discovery-style partial query", async () => {
+    const { runtimeManifest } = loadGeneratedCatalog();
+    const failures: Array<{ id: string; query: string }> = [];
+
+    for (const skill of runtimeManifest.skills) {
+      const query = buildDiscoveryQuery(skill);
+      const result = payload(
+        await handleSkillSearch({ query }, runtimeManifest, 200, 4),
+      );
+      const ids = (result.results as Array<{ id: string }>).map((item) => item.id);
+      if (!ids.includes(skill.id)) {
+        failures.push({ id: skill.id, query });
+      }
+    }
+
+    expect(failures).toEqual([]);
+  });
+
   it("returns full skill content for skill_get", async () => {
     const manifest = createManifest();
     const result = await handleSkillGet({ id: "react-expert" }, manifest, 4);
@@ -212,6 +674,92 @@ describe("skill tools", () => {
     });
   });
 
+  it("filters cross-skill markdown links out of availableReferences", async () => {
+    const dir = mkdtempSync(path.join(os.tmpdir(), "mcp-skill-validate-scope-"));
+    const skillFile = path.join(dir, "SKILL.md");
+    const referencesDir = path.join(dir, "references");
+    mkdirSync(referencesDir, { recursive: true });
+    writeFileSync(
+      skillFile,
+      [
+        "---",
+        "name: scoped-ref-skill",
+        "description: scoped refs",
+        "---",
+        "# Skill",
+        "See [Guide](references/guide.md).",
+        "See [Other Skill](../other-skill/SKILL.md).",
+      ].join("\n"),
+      "utf8",
+    );
+    writeFileSync(path.join(referencesDir, "guide.md"), "# Guide", "utf8");
+
+    const skillBytes = statSync(skillFile).size;
+    const manifest: VaultManifest = {
+      categories: ["general"],
+      skills: [
+        {
+          id: "scoped-ref-skill",
+          category: "general",
+          path: skillFile,
+          fileBytes: skillBytes,
+        },
+      ],
+      fullCatalogBytes: skillBytes,
+      fullCatalogEstimatedTokens: Math.ceil(skillBytes / 4),
+    };
+
+    const result = payload(
+      await handleSkillValidate({ id: "scoped-ref-skill" }, manifest, 4),
+    );
+    expect(result.availableReferences).toContain("references/guide.md");
+    expect(result.availableReferences).not.toContain("../other-skill/SKILL.md");
+  });
+
+  it("validates all generated alias skills against their canonical replacements", async () => {
+    const { generated, runtimeManifest } = loadGeneratedCatalog();
+    const aliases = generated.skills.filter(
+      (skill) => skill.metadata?.replaced_by || skill.metadata?.alias_of,
+    );
+    const failures: Array<{ id: string; expected: string | null; actual: unknown }> = [];
+
+    for (const alias of aliases) {
+      const runtimeSkill = runtimeManifest.skills.find((skill) => skill.id === alias.id);
+      if (!runtimeSkill || !existsSync(runtimeSkill.path)) {
+        failures.push({
+          id: alias.id,
+          expected: alias.metadata?.replaced_by ?? alias.metadata?.alias_of ?? null,
+          actual: "missing-skill-file",
+        });
+        continue;
+      }
+
+      const result = payload(
+        await handleSkillValidate({ id: alias.id }, runtimeManifest, 4),
+      );
+      const expectedCanonical =
+        alias.metadata?.replaced_by ?? alias.metadata?.alias_of ?? null;
+
+      if (
+        result.exists !== true ||
+        result.canonicalId !== expectedCanonical ||
+        result.isAlias !== true
+      ) {
+        failures.push({
+          id: alias.id,
+          expected: expectedCanonical,
+          actual: {
+            exists: result.exists,
+            canonicalId: result.canonicalId,
+            isAlias: result.isAlias,
+          },
+        });
+      }
+    }
+
+    expect(failures).toEqual([]);
+  });
+
   it("throws a wrapper guidance error when skill_validate receives workflow id", async () => {
     const manifest = createManifest();
     await expect(

package/mcp/src/tools/skillValidate.ts

@@ -28,7 +28,7 @@ export const skillValidateSchema = z.object({
 function assertConcreteSkillId(id: string) {
   if (id.startsWith("workflow-") || id.startsWith("agent-")) {
     invalidInput(
-      `Skill id "${id}" appears to be a wrapper id. Use workflow/agent routing (for example $workflow-implement-track or $agent-backend-specialist) and call skill_get only for concrete skill ids.`,
+      `Skill id "${id}" appears to be a wrapper id. Use route_resolve with an explicit workflow command, @agent mention, or compatibility alias before loading concrete skills.`,
     );
   }
 }
@@ -64,7 +64,7 @@ export async function handleSkillValidate(
 
     return {
       content: [{ type: "text" as const, text }],
-      structuredContent: { ...payload, metrics },
+      structuredContent: payload,
       _meta: { metrics },
     };
   }
@@ -95,7 +95,7 @@ export async function handleSkillValidate(
 
   return {
     content: [{ type: "text" as const, text }],
-    structuredContent: { ...payload, metrics },
+    structuredContent: payload,
     _meta: { metrics },
   };
 }

package/mcp/src/vault/manifest.ts

@@ -188,6 +188,24 @@ function collectReferencedMarkdownTargets(skillContent: string): string[] {
   return targets;
 }
 
+function normalizeInSkillMarkdownTarget(
+  skillDir: string,
+  target: string,
+): string | null {
+  const resolved = path.resolve(skillDir, target);
+  const relative = path.relative(skillDir, resolved);
+
+  if (relative.startsWith("..") || path.isAbsolute(relative)) {
+    return null;
+  }
+
+  if (path.basename(resolved).toLowerCase() === "skill.md") {
+    return null;
+  }
+
+  return relative.split(path.sep).join("/");
+}
+
 async function readReferencedMarkdownFiles(
   skillPath: string,
   skillContent: string,
@@ -266,7 +284,9 @@ export async function listReferencedMarkdownPaths(
 ): Promise<string[]> {
   const source = skillContent ?? (await readFullSkillContent(skillPath));
   const skillDir = path.dirname(skillPath);
-  const explicitTargets = collectReferencedMarkdownTargets(source);
+  const explicitTargets = collectReferencedMarkdownTargets(source)
+    .map((target) => normalizeInSkillMarkdownTarget(skillDir, target))
+    .filter((target): target is string => Boolean(target));
   const siblingTargets = await collectSiblingMarkdownTargets(skillDir);
   const merged = new Set<string>([...explicitTargets, ...siblingTargets]);
   return [...merged].sort((a, b) => a.localeCompare(b)).slice(0, MAX_REFERENCED_FILES);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cubis/foundry",
-  "version": "0.3.63",
+  "version": "0.3.64",
   "description": "Cubis Foundry CLI for workflow-first AI agent environments",
   "type": "module",
   "bin": {
@@ -29,8 +29,8 @@
   "scripts": {
     "start": "npm run build:cli && node bin/cubis.js",
     "check": "npm run build:cli && node bin/cubis.js --help",
-    "test:attributes": "node scripts/validate-platform-attributes.mjs",
-    "test:attributes:strict": "node scripts/validate-platform-attributes.mjs --strict",
+    "test:attributes": "node scripts/validate-platform-attributes.mjs && node scripts/validate-shared-routing.mjs && node scripts/validate-skill-packaging.mjs && node scripts/validate-runtime-wiring.mjs && node scripts/generate-skills-index.mjs --check",
+    "test:attributes:strict": "node scripts/validate-platform-attributes.mjs --strict && node scripts/validate-shared-routing.mjs && node scripts/validate-skill-packaging.mjs && node scripts/validate-runtime-wiring.mjs && node scripts/generate-skills-index.mjs --check",
     "test:tech-md": "node scripts/test-tech-md-scanner.mjs",
     "test:smoke": "npm run build:cli && bash scripts/smoke-workflows.sh",
     "test:init:tty": "npm run build:cli && expect scripts/test-init-tty.exp bin/cubis.js",
@@ -40,6 +40,7 @@
     "generate:platform-assets": "node scripts/generate-platform-assets.mjs",
     "sync:skill-mirrors": "node scripts/sync-skill-mirrors.mjs",
     "generate:skills-index": "node scripts/generate-skills-index.mjs",
+    "check:skills-index": "node scripts/generate-skills-index.mjs --check",
     "generate:mcp-manifest": "node scripts/generate-mcp-manifest.mjs",
     "generate:mcp-rules-block": "node scripts/generate-mcp-rules-block.mjs",
     "inject:mcp-rules:codex": "node scripts/generate-mcp-rules-block.mjs --inject workflows/workflows/agent-environment-setup/platforms/codex/rules/AGENTS.md",
@@ -62,7 +63,7 @@
     "generate:powers:sync": "node \"workflows/scripts/generate-powers.mjs\" --sync-skills --force",
     "build:cli": "tsc -p tsconfig.cli.json",
     "clean:cli": "rm -rf dist/cli",
-    "prepack": "npm run build:cli"
+    "prepack": "npm run build:cli && npm run check:skills-index"
   },
   "engines": {
     "node": ">=18.17"

package/src/cli/constants.ts

@@ -1,3 +1,3 @@
 export const CLI_NAME = "cbx";
 export const AGENT_ASSETS_SUBDIR = "workflows";
-export const DEFAULT_SKILL_PROFILE = "core";
+export const DEFAULT_SKILL_PROFILE = "full";