@moda-ai/cli 1.20.0 → 1.21.0

package/dist/init/sdk-protocol.d.ts

@@ -0,0 +1,135 @@
+import { z } from 'zod';
+export declare const SDK_RESULT_SCHEMA_VERSION = "moda.sdk_integration_result.v1";
+export declare const SDK_RESULT_JSON_BEGIN = "MODA_SDK_RESULT_JSON_BEGIN";
+export declare const SDK_RESULT_JSON_END = "MODA_SDK_RESULT_JSON_END";
+export declare const SDK_RESULT_FILE = ".moda/sdk-integration-result.json";
+export declare const SdkAgentResultSchema: z.ZodObject<{
+    schema_version: z.ZodPipeline<z.ZodString, z.ZodLiteral<"moda.sdk_integration_result.v1">>;
+    status: z.ZodEffects<z.ZodEnum<["integrated", "needs_human_input", "repository_checks_failed", "smoke_execution_failed", "nothing_to_integrate", "failed"]>, "failed" | "integrated" | "needs_human_input" | "repository_checks_failed" | "smoke_execution_failed" | "nothing_to_integrate", unknown>;
+    summary: z.ZodEffects<z.ZodString, string, unknown>;
+    skills_consulted: z.ZodDefault<z.ZodEffects<z.ZodArray<z.ZodEffects<z.ZodString, string, unknown>, "many">, string[], unknown>>;
+    skills_used: z.ZodDefault<z.ZodEffects<z.ZodArray<z.ZodEffects<z.ZodString, string, unknown>, "many">, string[], unknown>>;
+    packages_installed: z.ZodDefault<z.ZodEffects<z.ZodArray<z.ZodEffects<z.ZodString, string, unknown>, "many">, string[], unknown>>;
+    files_changed: z.ZodDefault<z.ZodEffects<z.ZodArray<z.ZodEffects<z.ZodString, string, unknown>, "many">, string[], unknown>>;
+    call_sites_instrumented: z.ZodDefault<z.ZodEffects<z.ZodArray<z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, unknown>, {
+        file: string;
+    }, unknown>, z.ZodObject<{
+        file: z.ZodEffects<z.ZodString, string, unknown>;
+        detail: z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, unknown>;
+    }, "strip", z.ZodTypeAny, {
+        file: string;
+        detail?: string | undefined;
+    }, {
+        file?: unknown;
+        detail?: unknown;
+    }>]>, "many">, ({
+        file: string;
+    } | {
+        file: string;
+        detail?: string | undefined;
+    })[], unknown>>;
+    commands_run: z.ZodDefault<z.ZodEffects<z.ZodArray<z.ZodObject<{
+        command: z.ZodEffects<z.ZodString, string, unknown>;
+        exit_code: z.ZodEffects<z.ZodUnion<[z.ZodNumber, z.ZodNull]>, number | null, unknown>;
+        kind: z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, unknown>;
+    }, "strip", z.ZodTypeAny, {
+        command: string;
+        exit_code: number | null;
+        kind?: string | undefined;
+    }, {
+        command?: unknown;
+        kind?: unknown;
+        exit_code?: unknown;
+    }>, "many">, {
+        command: string;
+        exit_code: number | null;
+        kind?: string | undefined;
+    }[], unknown>>;
+    smoke: z.ZodDefault<z.ZodEffects<z.ZodNullable<z.ZodObject<{
+        method: z.ZodEffects<z.ZodString, string, unknown>;
+        command: z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, unknown>;
+        verification_id: z.ZodEffects<z.ZodString, string, unknown>;
+    }, "strip", z.ZodTypeAny, {
+        method: string;
+        verification_id: string;
+        command?: string | undefined;
+    }, {
+        command?: unknown;
+        method?: unknown;
+        verification_id?: unknown;
+    }>>, {
+        method: string;
+        verification_id: string;
+        command?: string | undefined;
+    } | null, unknown>>;
+    remaining_actions: z.ZodDefault<z.ZodEffects<z.ZodArray<z.ZodEffects<z.ZodString, string, unknown>, "many">, string[], unknown>>;
+    failure: z.ZodDefault<z.ZodEffects<z.ZodNullable<z.ZodObject<{
+        class: z.ZodEffects<z.ZodString, string, unknown>;
+        detail: z.ZodEffects<z.ZodString, string, unknown>;
+    }, "strip", z.ZodTypeAny, {
+        detail: string;
+        class: string;
+    }, {
+        detail?: unknown;
+        class?: unknown;
+    }>>, {
+        detail: string;
+        class: string;
+    } | null, unknown>>;
+}, "strip", z.ZodTypeAny, {
+    schema_version: "moda.sdk_integration_result.v1";
+    summary: string;
+    status: "failed" | "integrated" | "needs_human_input" | "repository_checks_failed" | "smoke_execution_failed" | "nothing_to_integrate";
+    skills_consulted: string[];
+    skills_used: string[];
+    packages_installed: string[];
+    files_changed: string[];
+    call_sites_instrumented: ({
+        file: string;
+    } | {
+        file: string;
+        detail?: string | undefined;
+    })[];
+    commands_run: {
+        command: string;
+        exit_code: number | null;
+        kind?: string | undefined;
+    }[];
+    smoke: {
+        method: string;
+        verification_id: string;
+        command?: string | undefined;
+    } | null;
+    remaining_actions: string[];
+    failure: {
+        detail: string;
+        class: string;
+    } | null;
+}, {
+    schema_version: string;
+    summary?: unknown;
+    status?: unknown;
+    skills_consulted?: unknown;
+    skills_used?: unknown;
+    packages_installed?: unknown;
+    files_changed?: unknown;
+    call_sites_instrumented?: unknown;
+    commands_run?: unknown;
+    smoke?: unknown;
+    remaining_actions?: unknown;
+    failure?: unknown;
+}>;
+export type SdkAgentResult = z.infer<typeof SdkAgentResultSchema>;
+export type ExtractSdkAgentResult = {
+    result: SdkAgentResult;
+    source: 'file' | 'markers';
+} | {
+    error: string;
+    detail?: string;
+};
+export declare function extractSdkAgentResult(opts: {
+    cwd: string;
+    stdout: string;
+    stderr: string;
+}): ExtractSdkAgentResult;
+//# sourceMappingURL=sdk-protocol.d.ts.map

package/dist/init/sdk-protocol.js

@@ -0,0 +1,152 @@
+// src/init/sdk-protocol.ts — Versioned result protocol used by the coding
+// agent that performs SDK integration.
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { z } from 'zod';
+export const SDK_RESULT_SCHEMA_VERSION = 'moda.sdk_integration_result.v1';
+export const SDK_RESULT_JSON_BEGIN = 'MODA_SDK_RESULT_JSON_BEGIN';
+export const SDK_RESULT_JSON_END = 'MODA_SDK_RESULT_JSON_END';
+export const SDK_RESULT_FILE = '.moda/sdk-integration-result.json';
+const nonemptyString = z.preprocess((value) => {
+    if (typeof value === 'string')
+        return value.trim();
+    if (typeof value === 'number' || typeof value === 'boolean' || typeof value === 'bigint') {
+        return String(value);
+    }
+    return value;
+}, z.string().min(1));
+const optionalString = z.preprocess((value) => {
+    if (value === undefined)
+        return undefined;
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        return trimmed || undefined;
+    }
+    if (typeof value === 'number' || typeof value === 'boolean' || typeof value === 'bigint') {
+        return String(value);
+    }
+    return undefined;
+}, z.string().min(1).optional());
+function tolerantArray(itemSchema) {
+    return z.preprocess((value) => {
+        if (!Array.isArray(value))
+            return [];
+        const accepted = [];
+        for (const item of value) {
+            const parsed = itemSchema.safeParse(item);
+            if (parsed.success)
+                accepted.push(parsed.data);
+        }
+        return accepted;
+    }, z.array(itemSchema)).default([]);
+}
+const callSiteSchema = z.union([
+    nonemptyString.transform((file) => ({ file })),
+    z.object({
+        file: nonemptyString,
+        detail: optionalString,
+    }),
+]);
+const exitCodeSchema = z.preprocess((value) => {
+    if (value === null)
+        return null;
+    if (typeof value === 'string' && value.trim() !== '') {
+        const numeric = Number(value);
+        return Number.isFinite(numeric) ? numeric : value;
+    }
+    return value;
+}, z.union([z.number().finite(), z.null()]));
+const commandSchema = z.object({
+    command: nonemptyString,
+    exit_code: exitCodeSchema,
+    kind: optionalString,
+});
+const smokeSchema = z.object({
+    method: nonemptyString,
+    command: optionalString,
+    verification_id: nonemptyString,
+});
+const failureSchema = z.object({
+    class: nonemptyString,
+    detail: nonemptyString,
+});
+export const SdkAgentResultSchema = z.object({
+    schema_version: z.string().trim().pipe(z.literal(SDK_RESULT_SCHEMA_VERSION)),
+    status: z.preprocess((value) => typeof value === 'string' ? value.trim() : value, z.enum([
+        'integrated',
+        'needs_human_input',
+        'repository_checks_failed',
+        'smoke_execution_failed',
+        'nothing_to_integrate',
+        'failed',
+    ])),
+    summary: nonemptyString,
+    skills_consulted: tolerantArray(nonemptyString),
+    skills_used: tolerantArray(nonemptyString),
+    packages_installed: tolerantArray(nonemptyString),
+    files_changed: tolerantArray(nonemptyString),
+    call_sites_instrumented: tolerantArray(callSiteSchema),
+    commands_run: tolerantArray(commandSchema),
+    smoke: z.preprocess((value) => value ?? null, smokeSchema.nullable()).default(null),
+    remaining_actions: tolerantArray(nonemptyString),
+    failure: z.preprocess((value) => value ?? null, failureSchema.nullable()).default(null),
+});
+export function extractSdkAgentResult(opts) {
+    const diagnostics = [];
+    const resultPath = join(opts.cwd, SDK_RESULT_FILE);
+    if (existsSync(resultPath)) {
+        try {
+            const parsed = parseCandidate(readFileSync(resultPath, 'utf8'));
+            if (parsed.result)
+                return { result: parsed.result, source: 'file' };
+            diagnostics.push(`result file: ${parsed.detail}`);
+        }
+        catch (error) {
+            diagnostics.push(`result file: ${errorMessage(error)}`);
+        }
+    }
+    const output = [opts.stdout, opts.stderr].filter(Boolean).join('\n');
+    const candidates = markerCandidates(output);
+    for (const [index, candidate] of candidates.entries()) {
+        const parsed = parseCandidate(candidate);
+        if (parsed.result)
+            return { result: parsed.result, source: 'markers' };
+        diagnostics.push(`marker block ${index + 1}: ${parsed.detail}`);
+    }
+    if (candidates.length === 0) {
+        diagnostics.push(`no ${SDK_RESULT_JSON_BEGIN}/${SDK_RESULT_JSON_END} marker block found`);
+    }
+    return {
+        error: 'SDK integration result protocol violation.',
+        detail: diagnostics.join('; '),
+    };
+}
+function markerCandidates(output) {
+    const pattern = new RegExp(`${SDK_RESULT_JSON_BEGIN}\\s*([\\s\\S]*?)\\s*${SDK_RESULT_JSON_END}`, 'g');
+    const candidates = [];
+    for (const match of output.matchAll(pattern)) {
+        if (match[1])
+            candidates.push(match[1]);
+    }
+    return candidates;
+}
+function parseCandidate(candidate) {
+    let value;
+    try {
+        value = JSON.parse(candidate.trim());
+    }
+    catch (error) {
+        return { detail: `invalid JSON (${errorMessage(error)})` };
+    }
+    const parsed = SdkAgentResultSchema.safeParse(value);
+    if (parsed.success)
+        return { result: parsed.data };
+    const detail = parsed.error.issues
+        .map((issue) => `${issue.path.join('.') || '<root>'}: ${issue.message}`)
+        .join(', ');
+    return { detail: `validation failed (${detail})` };
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+//# sourceMappingURL=sdk-protocol.js.map

package/dist/init/sdk-verification.d.ts

@@ -0,0 +1,27 @@
+export interface VerificationEvidence {
+    observed: boolean;
+    verification_id: string;
+    total_spans: number;
+    llm_spans: number;
+    tool_spans: number;
+    trace_ids: string[];
+    orphan_count: number;
+    duplicate_count: number;
+    ingest_rows: number;
+    elapsed_ms: number;
+    polls: number;
+    last_error?: string;
+}
+export declare function generateVerificationId(): string;
+export declare function isModaVerificationId(value: string): boolean;
+export declare function verifyExactTrace(opts: {
+    verificationId: string;
+    timeoutMs?: number;
+    pollIntervalMs?: number;
+    fetchAudit?: (id: string) => Promise<unknown>;
+    sleep?: (ms: number) => Promise<void>;
+    now?: () => number;
+}): Promise<VerificationEvidence>;
+/** Fetch audit data for SDK verification using an explicit provisioned API key. */
+export declare function fetchAuditWithApiKey(id: string, apiKey: string, baseUrl: string): Promise<unknown>;
+//# sourceMappingURL=sdk-verification.d.ts.map

package/dist/init/sdk-verification.js

@@ -0,0 +1,123 @@
+// src/init/sdk-verification.ts — Poll the Data API for an exact, freshly
+// generated conversation id and require evidence of an observed LLM span.
+import { randomBytes } from 'node:crypto';
+const DEFAULT_TIMEOUT_MS = 90_000;
+const DEFAULT_POLL_INTERVAL_MS = 3_000;
+const MIN_TIMEOUT_MS = 10_000;
+const MAX_TIMEOUT_MS = 600_000;
+export function generateVerificationId() {
+    return `moda-verify-${randomBytes(16).toString('hex')}`;
+}
+export function isModaVerificationId(value) {
+    return /^moda-verify-[0-9a-f]{32}$/.test(value);
+}
+export async function verifyExactTrace(opts) {
+    const now = opts.now ?? Date.now;
+    const sleep = opts.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+    // Verification MUST poll with the provisioned key (fetchAuditWithApiKey) so an
+    // ambient MODA_API_KEY pointing at another tenant cannot skew the result.
+    // Fail explicitly rather than silently falling back to ambient credentials.
+    const fetchAudit = opts.fetchAudit;
+    const timeoutMs = opts.timeoutMs === undefined || !Number.isFinite(opts.timeoutMs)
+        ? resolveTimeoutFromEnv()
+        : Math.max(0, opts.timeoutMs);
+    const requestedPollInterval = opts.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+    const pollIntervalMs = Number.isFinite(requestedPollInterval)
+        ? Math.max(1, requestedPollInterval)
+        : DEFAULT_POLL_INTERVAL_MS;
+    const startedAt = now();
+    const deadline = startedAt + Math.max(0, timeoutMs);
+    let polls = 0;
+    let lastError;
+    let counts = {
+        total_spans: 0,
+        llm_spans: 0,
+        tool_spans: 0,
+        trace_ids: [],
+        orphan_count: 0,
+        duplicate_count: 0,
+        ingest_rows: 0,
+    };
+    if (!fetchAudit) {
+        lastError = 'verification requires an explicit audit fetcher bound to the provisioned API key';
+        return buildEvidence(false);
+    }
+    while (true) {
+        polls++;
+        try {
+            const response = await fetchAudit(opts.verificationId);
+            const parsed = readAuditCounts(response);
+            if (parsed) {
+                counts = parsed;
+                if (counts.total_spans >= 1 && counts.llm_spans >= 1) {
+                    return buildEvidence(true);
+                }
+            }
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error.message : String(error);
+        }
+        const currentTime = now();
+        if (currentTime >= deadline)
+            return buildEvidence(false);
+        await sleep(Math.min(pollIntervalMs, deadline - currentTime));
+    }
+    function buildEvidence(observed) {
+        return {
+            observed,
+            verification_id: opts.verificationId,
+            ...counts,
+            elapsed_ms: Math.max(0, now() - startedAt),
+            polls,
+            ...(lastError ? { last_error: lastError } : {}),
+        };
+    }
+}
+function resolveTimeoutFromEnv() {
+    const raw = process.env.MODA_SDK_VERIFY_TIMEOUT_MS;
+    if (!raw)
+        return DEFAULT_TIMEOUT_MS;
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed))
+        return DEFAULT_TIMEOUT_MS;
+    return Math.min(MAX_TIMEOUT_MS, Math.max(MIN_TIMEOUT_MS, Math.trunc(parsed)));
+}
+function readAuditCounts(value) {
+    if (!isRecord(value) || !isRecord(value.summary))
+        return undefined;
+    const summary = value.summary;
+    if (!isNonNegativeNumber(summary.total_spans) || !isRecord(summary.by_type))
+        return undefined;
+    return {
+        total_spans: summary.total_spans,
+        llm_spans: isNonNegativeNumber(summary.by_type.llm) ? summary.by_type.llm : 0,
+        tool_spans: isNonNegativeNumber(summary.by_type.tool) ? summary.by_type.tool : 0,
+        trace_ids: Array.isArray(summary.trace_ids)
+            ? summary.trace_ids.filter((item) => typeof item === 'string')
+            : [],
+        orphan_count: isNonNegativeNumber(summary.orphan_count) ? summary.orphan_count : 0,
+        duplicate_count: isNonNegativeNumber(summary.duplicate_count) ? summary.duplicate_count : 0,
+        ingest_rows: isNonNegativeNumber(summary.ingest_rows) ? summary.ingest_rows : 0,
+    };
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isNonNegativeNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0;
+}
+/** Fetch audit data for SDK verification using an explicit provisioned API key. */
+export async function fetchAuditWithApiKey(id, apiKey, baseUrl) {
+    const url = `${baseUrl}/api/v1/data/audit/${encodeURIComponent(id)}?kind=conversation`;
+    const response = await fetch(url, {
+        method: 'GET',
+        headers: { 'x-api-key': apiKey },
+        signal: AbortSignal.timeout(10_000),
+    });
+    const body = await response.text();
+    if (!response.ok) {
+        throw new Error(`Audit fetch failed (${response.status}): ${body.slice(0, 200)}`);
+    }
+    return JSON.parse(body);
+}
+//# sourceMappingURL=sdk-verification.js.map

package/dist/sync.js

@@ -1,6 +1,7 @@
 import { CliInputError } from './errors.js';
 import { runHarnessCommand } from './harness.js';
 import { runPromptsCommand } from './prompts.js';
+import { runSkillsCommand } from './skills.js';
 export async function runSyncCommand(context) {
     const resource = context.positionals[0] ?? 'harness';
     const rest = context.positionals.slice(1);
@@ -20,8 +21,16 @@ export async function runSyncCommand(context) {
         return { exitCode: 0 };
     }
     if (resource === 'skills') {
-        throw new CliInputError('`moda sync skills` is not implemented yet.', 'Use `moda skills gen` to ask Moda to generate skills, then `moda skills pull` to install approved skills locally.');
+        // Skills surface is pull-oriented (install approved skills locally), unlike
+        // prompts sync which pushes authored config upstream.
+        const exitCode = await runSkillsCommand({
+            ...context,
+            command: 'skills',
+            positional: 'pull',
+            positionals: ['pull', ...rest],
+        });
+        return { exitCode };
     }
-    throw new CliInputError(`Unknown sync resource '${resource}'.`, 'Usage: moda sync [harness|prompts] [--dry-run] [--profile=NAME]');
+    throw new CliInputError(`Unknown sync resource '${resource}'.`, 'Usage: moda sync [harness|prompts|skills] [--dry-run] [--profile=NAME]');
 }
 //# sourceMappingURL=sync.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moda-ai/cli",
-  "version": "1.20.0",
+  "version": "1.21.0",
   "description": "CLI for Moda - AI agent analytics and observability",
   "type": "module",
   "bin": {

package/skills/integration/index.json

@@ -1,7 +1,7 @@
 {
   "schema_version": "moda.skill_index.v1",
-  "bundled_at": "2026-07-11T21:49:32.595Z",
-  "cli_version": "1.20.0",
+  "bundled_at": "2026-07-12T21:12:37.084Z",
+  "cli_version": "1.21.0",
   "skills": [
     {
       "id": "integration-node-anthropic",

package/dist/init/skill-resolver.d.ts

@@ -1,19 +0,0 @@
-import type { SdkGuideContext } from './sdk-guide.js';
-type Language = 'node' | 'python';
-type Framework = 'vercel-ai-sdk' | 'langchain' | 'claude-agent-sdk';
-type Provider = 'openai' | 'anthropic';
-interface ResolutionRow {
-    language: Language;
-    framework?: Framework;
-    provider?: Provider;
-    skillId: string;
-}
-/** The §2.3 resolution table, encoded as data. Order matters. */
-export declare const RESOLUTION_TABLE: readonly ResolutionRow[];
-/**
- * Resolve the detected context to a bundled skill id, or null when no
- * language was detected (callers fall back to the slim generic guide).
- */
-export declare function resolveIntegrationSkillId(context: SdkGuideContext): string | null;
-export {};
-//# sourceMappingURL=skill-resolver.d.ts.map

package/dist/init/skill-resolver.js

@@ -1,78 +0,0 @@
-// src/init/skill-resolver.ts — deterministic resolution from detected project
-// context to a bundled integration-skill id.
-//
-// Pure function, zero LLM involvement. The table is ordered; the first
-// matching row wins. Wrapper frameworks beat raw providers: if the Vercel AI
-// SDK or LangChain is present, the wrapper layer gets instrumented, never the
-// underlying openai/anthropic client.
-/** The §2.3 resolution table, encoded as data. Order matters. */
-export const RESOLUTION_TABLE = [
-    { language: 'node', framework: 'vercel-ai-sdk', skillId: 'integration-node-vercel-ai-sdk' },
-    { language: 'node', framework: 'langchain', skillId: 'integration-node-langchain' },
-    { language: 'python', framework: 'langchain', skillId: 'integration-python-langchain' },
-    { language: 'python', framework: 'claude-agent-sdk', skillId: 'integration-python-claude-agent-sdk' },
-    { language: 'node', provider: 'openai', skillId: 'integration-node-openai' },
-    { language: 'node', provider: 'anthropic', skillId: 'integration-node-anthropic' },
-    { language: 'python', provider: 'openai', skillId: 'integration-python-openai' },
-    { language: 'python', provider: 'anthropic', skillId: 'integration-python-anthropic' },
-    { language: 'node', skillId: 'integration-node-generic' },
-    { language: 'python', skillId: 'integration-python-generic' },
-];
-/**
- * Resolve the detected context to a bundled skill id, or null when no
- * language was detected (callers fall back to the slim generic guide).
- */
-export function resolveIntegrationSkillId(context) {
-    const languages = normalizeLanguages(context.languages);
-    const frameworks = normalizeFrameworks(context.frameworkHints);
-    const providers = normalizeProviders(context.providerHints);
-    for (const row of RESOLUTION_TABLE) {
-        if (!languages.has(row.language))
-            continue;
-        if (row.framework && !frameworks.has(row.framework))
-            continue;
-        if (row.provider && !providers.has(row.provider))
-            continue;
-        return row.skillId;
-    }
-    return null;
-}
-function normalizeLanguages(languages) {
-    const result = new Set();
-    for (const language of languages) {
-        const lower = language.toLowerCase();
-        if (lower.includes('node') || lower.includes('typescript') || lower.includes('javascript')) {
-            result.add('node');
-        }
-        if (lower.includes('python'))
-            result.add('python');
-    }
-    return result;
-}
-function normalizeFrameworks(frameworkHints) {
-    const result = new Set();
-    for (const hint of frameworkHints) {
-        const lower = hint.toLowerCase();
-        if (lower.includes('vercel ai sdk') || lower.includes('vercel-ai-sdk') || lower.includes('ai sdk')) {
-            result.add('vercel-ai-sdk');
-        }
-        if (lower.includes('langchain') || lower.includes('langgraph'))
-            result.add('langchain');
-        if (lower.includes('claude agent sdk') || lower.includes('claude-agent-sdk')) {
-            result.add('claude-agent-sdk');
-        }
-    }
-    return result;
-}
-function normalizeProviders(providerHints) {
-    const result = new Set();
-    for (const hint of providerHints) {
-        const lower = hint.toLowerCase();
-        if (lower.includes('openai'))
-            result.add('openai');
-        if (lower.includes('anthropic'))
-            result.add('anthropic');
-    }
-    return result;
-}
-//# sourceMappingURL=skill-resolver.js.map