specrails-desktop 2.30.2 → 2.31.0

package/server/dist/providers/kimi-adapter.js

@@ -0,0 +1,361 @@
+"use strict";
+// Kimi Code CLI adapter for 0.27.0+.
+//
+// Official headless contract:
+//   kimi -m <configured-alias> -p <prompt> --output-format stream-json
+//   kimi -m <configured-alias> --session=<session-id> -p <prompt> --output-format stream-json
+//
+// Prompt mode owns its automatic permission policy and cannot be combined with
+// --auto/--yolo/--plan. Kimi emits JSONL assistant/tool/meta records and a
+// successful terminal `session.resume_hint`, but no authoritative token or USD
+// cost envelope.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._KIMI_MODELS = exports._KIMI_MIN_VERSION = exports.kimiAdapter = void 0;
+exports._compareSemver = compareSemver;
+exports._normaliseKimiModel = normaliseKimiModel;
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+const win_spawn_1 = require("../util/win-spawn");
+const kimi_skill_prompt_1 = require("./kimi-skill-prompt");
+const runtime_1 = require("./runtime");
+const whichCommand = () => process.platform === 'win32' ? 'where' : 'which';
+const KIMI_MIN_VERSION = '0.27.0';
+exports._KIMI_MIN_VERSION = KIMI_MIN_VERSION;
+const KIMI_MODELS = [
+    { value: 'k3', label: 'Kimi K3', default: true },
+    { value: 'kimi-for-coding', label: 'Kimi for Coding' },
+    { value: 'kimi-for-coding-highspeed', label: 'Kimi for Coding Highspeed' },
+];
+exports._KIMI_MODELS = KIMI_MODELS;
+const OFFICIAL_RAW_MODELS = new Set(KIMI_MODELS.map((model) => model.value));
+const KIMI_EFFORTS = new Set(['low', 'high', 'max']);
+const STREAM_JSON_FLAGS = ['--output-format', 'stream-json'];
+// Keep this aligned with specrails-core's public Kimi runner contract. The
+// host trusts a resume hint only after both parser and argv construction have
+// enforced the same bounded grammar.
+const KIMI_SESSION_ID_MAX_LENGTH = 128;
+const KIMI_SESSION_ID_PATTERN = /^[A-Za-z0-9._-]+$/;
+function normaliseKimiModel(model) {
+    return OFFICIAL_RAW_MODELS.has(model) ? `kimi-code/${model}` : model;
+}
+function isK3Model(model) {
+    return model === 'k3' || model === 'kimi-code/k3';
+}
+function isSafeKimiSessionId(sessionId) {
+    return sessionId.length > 0
+        && sessionId.length <= KIMI_SESSION_ID_MAX_LENGTH
+        && sessionId !== '.'
+        && sessionId !== '..'
+        && KIMI_SESSION_ID_PATTERN.test(sessionId);
+}
+function kimiSessionOption(sessionId) {
+    if (!isSafeKimiSessionId(sessionId)) {
+        throw new Error('invalid_kimi_session_id');
+    }
+    // Commander's optional `[id]` value can reinterpret a following `--value`
+    // as another flag. The equals form binds even option-shaped, otherwise-safe
+    // upstream ids to the session option.
+    return `--session=${sessionId}`;
+}
+function fold(systemPrompt, prompt) {
+    return systemPrompt ? `${systemPrompt}\n\n---\n\n${prompt}` : prompt;
+}
+function appendMediaGuidance(prompt, imagePaths) {
+    if (!imagePaths?.length)
+        return prompt;
+    const files = imagePaths.map((imagePath) => `- ${path_1.default.resolve(imagePath)}`).join('\n');
+    return [
+        prompt,
+        '',
+        'Attached media files:',
+        files,
+        'Use ReadMediaFile to inspect each attached media file before responding.',
+    ].join('\n');
+}
+function promptFor(action, opts) {
+    // Explore chat cwd owns AGENTS.md. Keeping the user turn short avoids
+    // overpowering it with a repeated system prompt on every resume.
+    const prompt = action === 'chat-turn' || action === 'chat-resume'
+        ? opts.prompt
+        : fold(opts.systemPrompt, opts.prompt);
+    return appendMediaGuidance(prompt, opts.imagePaths);
+}
+function buildKimiArgs(action, opts) {
+    if (action === 'chat-stream') {
+        throw new Error('kimi does not support persistent stdin streaming (chat-stream)');
+    }
+    // Print mode does not run Kimi's TUI/ACP slash-command interceptor. Every
+    // Core/skill spawn boundary must materialize the SKILL.md first; reject a
+    // missed callsite here so it cannot settle as a deceptive zero-work success.
+    if (/^\/(?:skill|specrails|sr|opsx):[^\s]+/.test(opts.prompt.trimStart())) {
+        throw new Error('kimi_headless_skill_not_materialized');
+    }
+    // Kimi Code 0.27 prompt mode creates/resumes sessions in `auto` permission
+    // mode and installs an approval handler that approves every tool call;
+    // `--prompt` also rejects `--plan`. Enforce the capability contract here as
+    // the final backstop: no caller may silently turn `none`/`read-only` into an
+    // autonomous invocation. AI auto-title is intrinsically pure-output, so it
+    // fails closed even if an older caller omitted the explicit policy.
+    const requestedToolPolicy = action === 'auto-title' ? 'none' : (opts.toolPolicy ?? 'default');
+    if (requestedToolPolicy !== 'default') {
+        throw new Error(`provider_tool_policy_unsupported:kimi:${requestedToolPolicy}`);
+    }
+    // Routes and selectors validate custom aliases, but restored queue state and
+    // internal callers can bypass those surfaces. Keep the spawn boundary
+    // authoritative so a corrupt value can never become a CLI flag.
+    if (!(0, runtime_1.isSafeCustomModelAlias)(opts.model)) {
+        throw new Error('invalid_provider_model_alias:kimi');
+    }
+    const requiresSession = action === 'chat-resume' || action === 'setup-enrich-resume';
+    if (requiresSession && !opts.sessionId)
+        throw new Error(`${action} requires sessionId`);
+    const args = ['-m', normaliseKimiModel(opts.model)];
+    if (opts.sessionId && (requiresSession || action === 'agent-refine')) {
+        args.push(kimiSessionOption(opts.sessionId));
+    }
+    args.push('-p', promptFor(action, opts), ...STREAM_JSON_FLAGS);
+    if (opts.extraArgs)
+        args.push(...opts.extraArgs);
+    return args;
+}
+function contentText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    return content
+        .map((part) => {
+        if (typeof part === 'string')
+            return part;
+        if (!part || typeof part !== 'object')
+            return '';
+        const record = part;
+        return typeof record.text === 'string' ? record.text : '';
+    })
+        .filter(Boolean)
+        .join('');
+}
+function stringifyPreview(value) {
+    if (typeof value === 'string')
+        return value.slice(0, 200);
+    try {
+        return JSON.stringify(value ?? '').slice(0, 200);
+    }
+    catch {
+        return String(value ?? '').slice(0, 200);
+    }
+}
+function errorMessage(parsed) {
+    if (typeof parsed.message === 'string')
+        return parsed.message;
+    if (typeof parsed.content === 'string')
+        return parsed.content;
+    if (parsed.error && typeof parsed.error === 'object') {
+        const nested = parsed.error;
+        if (typeof nested.message === 'string')
+            return nested.message;
+        return stringifyPreview(nested);
+    }
+    return 'Kimi invocation failed';
+}
+function assistantEvents(parsed) {
+    const events = [];
+    const text = contentText(parsed.content);
+    if (text)
+        events.push({ kind: 'text-delta', text });
+    const calls = Array.isArray(parsed.tool_calls) ? parsed.tool_calls : [];
+    for (const call of calls) {
+        if (!call || typeof call !== 'object')
+            continue;
+        const functionRecord = call.function;
+        if (!functionRecord || typeof functionRecord !== 'object')
+            continue;
+        const fn = functionRecord;
+        events.push({
+            kind: 'tool-use',
+            name: typeof fn.name === 'string' ? fn.name : '<unnamed>',
+            inputPreview: stringifyPreview(fn.arguments),
+        });
+    }
+    if (events.length === 0) {
+        return { kind: 'other', type: 'assistant', raw: parsed };
+    }
+    return events.length === 1 ? events[0] : events;
+}
+function parseKimiStreamLine(line) {
+    if (line.trim().length === 0)
+        return null;
+    let parsed;
+    try {
+        const value = JSON.parse(line);
+        if (!value || typeof value !== 'object' || Array.isArray(value))
+            return null;
+        parsed = value;
+    }
+    catch {
+        return null;
+    }
+    const role = typeof parsed.role === 'string' ? parsed.role : undefined;
+    const type = typeof parsed.type === 'string' ? parsed.type : undefined;
+    if (role === 'meta' && type === 'session.resume_hint') {
+        const sessionId = typeof parsed.session_id === 'string' ? parsed.session_id : '';
+        if (!sessionId)
+            return { kind: 'other', type, raw: parsed };
+        return isSafeKimiSessionId(sessionId)
+            ? { kind: 'session-started', sessionId }
+            : { kind: 'error', message: 'Kimi emitted an invalid session id' };
+    }
+    if (role === 'error' ||
+        type === 'error' ||
+        type === 'system.error' ||
+        type?.endsWith('.failed')) {
+        return { kind: 'error', message: errorMessage(parsed) };
+    }
+    if (role === 'assistant')
+        return assistantEvents(parsed);
+    // Tool results, retry records, system.version, and future meta records remain
+    // available as `other` diagnostics instead of being discarded.
+    return { kind: 'other', type: type ?? role ?? '<missing>', raw: parsed };
+}
+function extractKimiResult(events) {
+    let sessionId;
+    for (const event of events) {
+        if (event.kind === 'session-started')
+            sessionId = event.sessionId;
+    }
+    return {
+        session_id: sessionId,
+    };
+}
+function compareSemver(a, b) {
+    const left = a.split('.').map((value) => Number.parseInt(value, 10));
+    const right = b.split('.').map((value) => Number.parseInt(value, 10));
+    for (let index = 0; index < 3; index += 1) {
+        const delta = (left[index] ?? 0) - (right[index] ?? 0);
+        if (delta !== 0)
+            return delta > 0 ? 1 : -1;
+    }
+    return 0;
+}
+async function detectKimiInstalled() {
+    const env = (0, win_spawn_1.windowsSpawnEnv)();
+    try {
+        (0, child_process_1.execSync)(`${whichCommand()} kimi`, { stdio: 'ignore', env });
+    }
+    catch {
+        return { installed: false, executable: false };
+    }
+    try {
+        // The only official, non-billable bounded readiness probe is --version.
+        // Authentication has no safe probe in 0.27; setup directs users to login.
+        // `exec` intentionally uses the platform shell for this constant command:
+        // Windows npm installs expose `kimi.cmd`, which direct execFile cannot
+        // launch. No user-controlled text enters this command.
+        const raw = (0, child_process_1.execSync)('kimi --version', {
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+            // ProviderAdapter.detectInstalled() is a UI/startup health probe. Keep
+            // the contract's hard three-second ceiling on every platform, including
+            // npm-installed Windows `.cmd` shims.
+            timeout: 3_000,
+            env,
+        }).trim();
+        const match = raw.match(/\d+\.\d+\.\d+/);
+        const version = match?.[0] ?? raw;
+        const meetsMinimum = !!match && compareSemver(version, KIMI_MIN_VERSION) >= 0;
+        return {
+            installed: true,
+            executable: true,
+            version,
+            meetsMinimum,
+            ...(!meetsMinimum
+                ? {
+                    error: `kimi ${version || '?'} is older than required ${KIMI_MIN_VERSION}. ` +
+                        'Install the latest Kimi Code, run `kimi login`, then restart Specrails.',
+                }
+                : {}),
+        };
+    }
+    catch {
+        return { installed: true, executable: false };
+    }
+}
+function buildKimiEnv(opts) {
+    const effort = opts.reasoning_effort;
+    return {
+        KIMI_MODEL_THINKING_EFFORT: isK3Model(opts.model) && effort && KIMI_EFFORTS.has(effort)
+            ? effort
+            : undefined,
+        // Desktop's stream parser and permission analysis are qualified against
+        // Kimi Code 0.27's stable v1 engine. Never inherit the user's experimental
+        // v2 opt-in: it selects a different runtime with an unverified policy
+        // wiring and would silently invalidate those guarantees.
+        KIMI_CODE_EXPERIMENTAL_FLAG: undefined,
+        // Prompt mode auto-approves tools. Desktop has no scheduler lifecycle/UI
+        // for Kimi's persistent CronCreate facility, so prevent a managed child
+        // from leaving scheduled work behind after its owned process exits.
+        KIMI_DISABLE_CRON: '1',
+        // A managed invocation must run the version that passed Desktop's
+        // compatibility probe, not mutate the external CLI during startup.
+        KIMI_CODE_NO_AUTO_UPDATE: '1',
+    };
+}
+exports.kimiAdapter = {
+    id: 'kimi',
+    displayName: 'Kimi Code',
+    binary: 'kimi',
+    minCliVersion: KIMI_MIN_VERSION,
+    projectDirName: '.kimi-code',
+    // Unlike Codex's root AGENTS.md, Kimi's provider-local project instructions
+    // live inside its project tree. Keep the relative path explicit so isolated
+    // Explore workspaces and integration guidance land where Kimi actually
+    // loads them.
+    instructionsFilename: path_1.default.join('.kimi-code', 'AGENTS.md'),
+    mcpRegistration: 'project-json',
+    capabilities: {
+        nativeResume: true,
+        nativeStreamJson: true,
+        nativeCostUsd: false,
+        reportsUsage: false,
+        nativeOtelEnv: false,
+        profileEnvSupport: true,
+        systemPromptArg: false,
+        foldProjectChatSystemPrompt: true,
+        persistentStdin: false,
+        supportsReasoningEffort: true,
+        reasoningEfforts: ['low', 'high', 'max'],
+        // Kimi has no image argv; validated absolute paths are inspected through
+        // ReadMediaFile by provider-neutral workflow guidance.
+        supportsImageInput: true,
+        structuredActions: false,
+        toolPolicies: [],
+        profiles: true,
+        // Kimi aliases are configured by the user; the built-in catalog is only a
+        // convenient default/discovery set, not an exhaustive validation boundary.
+        customModelAliases: true,
+        customRoles: true,
+        materializeHeadlessSkills: true,
+        freestyle: true,
+        userMcp: false,
+    },
+    modelCatalog: () => KIMI_MODELS,
+    defaultModel: () => 'k3',
+    reasoningEffortsForModel: (model) => isK3Model(model) ? ['low', 'high', 'max'] : [],
+    buildArgs: buildKimiArgs,
+    buildEnv: buildKimiEnv,
+    formatCoreCommand: kimi_skill_prompt_1.formatKimiCoreCommand,
+    buildRepoAccessArgs: (paths) => paths.flatMap((repoPath) => ['--add-dir', repoPath]),
+    projectMcpPath: (root) => path_1.default.join(root, '.kimi-code', 'mcp.json'),
+    customRolePath: (root, roleId) => 
+    // Kimi discovers only direct children of each skills root:
+    // `.kimi-code/skills/<name>/SKILL.md`. A nested `skills/rails/<name>`
+    // catalog is not scanned by the upstream CLI.
+    path_1.default.join(root, '.kimi-code', 'skills', roleId, 'SKILL.md'),
+    parseStreamLine: parseKimiStreamLine,
+    extractResult: extractKimiResult,
+    baselineAgents: () => ['sr-architect', 'sr-developer', 'sr-reviewer'],
+    detectInstalled: detectKimiInstalled,
+};

package/server/dist/providers/kimi-skill-prompt.js

@@ -0,0 +1,332 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._test = exports.KimiSkillResolutionError = void 0;
+exports.parseKimiSkillDocument = parseKimiSkillDocument;
+exports.validateKimiRoleDocument = validateKimiRoleDocument;
+exports.formatKimiCoreCommand = formatKimiCoreCommand;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const js_yaml_1 = require("js-yaml");
+const SAFE_SKILL_NAME_RE = /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
+const OPSX_TO_KIMI_SKILL = {
+    propose: 'openspec-propose',
+    ff: 'openspec-ff-change',
+    new: 'openspec-new-change',
+    apply: 'openspec-apply-change',
+    continue: 'openspec-continue-change',
+    archive: 'openspec-archive-change',
+    'bulk-archive': 'openspec-bulk-archive-change',
+    sync: 'openspec-sync-specs',
+    verify: 'openspec-verify-change',
+    explore: 'openspec-explore',
+    onboard: 'openspec-onboard',
+};
+/**
+ * Raised before a provider process is spawned when a Kimi headless command
+ * cannot be resolved safely. Sending the original `/skill:*` text to `kimi -p`
+ * would be a silent no-op: Kimi 0.27 intercepts slash skills in its TUI/ACP
+ * clients, while print mode sends its prompt straight to `session.prompt()`.
+ */
+class KimiSkillResolutionError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'KimiSkillResolutionError';
+    }
+}
+exports.KimiSkillResolutionError = KimiSkillResolutionError;
+function parseInvocation(command) {
+    const match = command.match(/^\/(skill|specrails|sr|opsx):([^\s]+)(?:\s+([\s\S]*))?$/);
+    if (!match)
+        return null;
+    const namespace = match[1];
+    const rawName = match[2];
+    const rawArgs = (match[3] ?? '').trim();
+    let skillName;
+    if (namespace === 'skill')
+        skillName = rawName;
+    else if (namespace === 'specrails' || namespace === 'sr') {
+        skillName = `specrails-${rawName}`;
+    }
+    else {
+        skillName = OPSX_TO_KIMI_SKILL[rawName];
+        if (!skillName)
+            return null;
+    }
+    if (!SAFE_SKILL_NAME_RE.test(skillName)) {
+        throw new KimiSkillResolutionError(`Unsafe Kimi skill name "${skillName}". Expected letters, digits, "_" or "-".`);
+    }
+    return { skillName, rawArgs };
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function nonEmptyString(value) {
+    return typeof value === 'string' && value.trim() !== '' ? value.trim() : undefined;
+}
+function skillArgumentNames(value) {
+    const isValid = (name) => name.trim() !== '' && !/^\d+$/.test(name);
+    if (typeof value === 'string')
+        return value.split(/\s+/).filter(isValid);
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((item) => typeof item === 'string' && isValid(item));
+}
+/** Parse a directory SKILL.md with Kimi 0.27's frontmatter requirements.
+ *
+ * This is intentionally exported as the single parser for both execution and
+ * Profiles CRUD. Keeping the js-yaml parse and type checks here prevents the
+ * editor from accepting a role that the headless execution path would later
+ * reject.
+ */
+function parseKimiSkillDocument(source, skillPath = '<memory>') {
+    const lines = source.split(/\r?\n/);
+    if (lines[0]?.trim() !== '---') {
+        throw new KimiSkillResolutionError(`Missing frontmatter in ${skillPath}`);
+    }
+    const close = lines.findIndex((line, index) => index > 0 && line.trim() === '---');
+    if (close < 0) {
+        throw new KimiSkillResolutionError(`Invalid frontmatter in ${skillPath}: missing closing fence`);
+    }
+    const yamlText = lines.slice(1, close).join('\n').trim();
+    let parsed;
+    try {
+        parsed = yamlText === '' ? {} : ((0, js_yaml_1.load)(yamlText) ?? {});
+    }
+    catch (error) {
+        throw new KimiSkillResolutionError(`Invalid frontmatter in ${skillPath}: ` +
+            (error instanceof Error ? error.message : String(error)));
+    }
+    if (!isRecord(parsed)) {
+        throw new KimiSkillResolutionError(`Frontmatter in ${skillPath} must be a mapping at the top level`);
+    }
+    const name = nonEmptyString(parsed.name);
+    const description = nonEmptyString(parsed.description);
+    if (!name || !description) {
+        throw new KimiSkillResolutionError(`Missing required frontmatter field ${!name ? '"name"' : '"description"'} in ${skillPath}`);
+    }
+    const hasType = Object.prototype.hasOwnProperty.call(parsed, 'type');
+    if (hasType
+        && (typeof parsed.type !== 'string' || parsed.type.trim() === '')) {
+        throw new KimiSkillResolutionError(`Skill type "${String(parsed.type)}" is not supported in ${skillPath}`);
+    }
+    const type = nonEmptyString(parsed.type);
+    if (type !== undefined &&
+        type !== 'prompt' &&
+        type !== 'inline' &&
+        type !== 'flow' &&
+        type !== 'reference') {
+        throw new KimiSkillResolutionError(`Skill type "${type}" is not supported in ${skillPath}`);
+    }
+    if (type === 'reference') {
+        throw new KimiSkillResolutionError(`Kimi skill "${name}" has type "reference" and cannot be activated by the user.`);
+    }
+    return {
+        body: lines.slice(close + 1).join('\n').trim(),
+        metadataName: name,
+        description,
+        argumentNames: skillArgumentNames(parsed.arguments),
+    };
+}
+/**
+ * Validate a user-authored role against the same document contract used at
+ * execution time. The expected-name check is a Profiles invariant: the
+ * provider-native metadata must identify the direct-child role directory.
+ */
+function validateKimiRoleDocument(source, expectedName, skillPath = '<memory>') {
+    let document;
+    try {
+        document = parseKimiSkillDocument(source, skillPath);
+    }
+    catch (error) {
+        return [
+            error instanceof Error
+                ? error.message
+                : `Invalid Kimi skill document in ${skillPath}`,
+        ];
+    }
+    const errors = [];
+    if (document.metadataName !== expectedName) {
+        errors.push(`frontmatter.name must exactly match '${expectedName}'`);
+    }
+    if (!document.body) {
+        errors.push(`Kimi skill "${expectedName}" has an empty body.`);
+    }
+    return errors;
+}
+function tokenizeArgs(raw) {
+    const out = [];
+    let current = '';
+    let quote;
+    let hasContent = false;
+    for (const char of raw) {
+        if (quote !== undefined) {
+            if (char === quote) {
+                quote = undefined;
+            }
+            else {
+                current += char;
+                hasContent = true;
+            }
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            quote = char;
+            hasContent = true;
+            continue;
+        }
+        if (/\s/.test(char)) {
+            if (hasContent) {
+                out.push(current);
+                current = '';
+                hasContent = false;
+            }
+            continue;
+        }
+        current += char;
+        hasContent = true;
+    }
+    if (hasContent)
+        out.push(current);
+    return out;
+}
+function regexpEscape(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function escapeXmlTags(value) {
+    return value.replaceAll('<', '&lt;').replaceAll('>', '&gt;');
+}
+function escapeXml(value) {
+    return value
+        .replaceAll('&', '&amp;')
+        .replaceAll('<', '&lt;')
+        .replaceAll('>', '&gt;')
+        .replaceAll('"', '&quot;');
+}
+function expandSkillParameters(body, rawArgs, skillDir, argumentNames, sessionId) {
+    const tokens = tokenizeArgs(rawArgs);
+    let content = body;
+    for (let index = 0; index < argumentNames.length; index += 1) {
+        const escaped = regexpEscape(argumentNames[index]);
+        content = content.replace(new RegExp(`\\$${escaped}(?![\\[\\w])`, 'g'), escapeXmlTags(tokens[index] ?? ''));
+    }
+    content = content
+        .replace(/\$ARGUMENTS\[(\d+)\]/g, (_match, indexText) => escapeXmlTags(tokens[Number.parseInt(indexText, 10)] ?? ''))
+        .replace(/\$(\d+)(?!\w)/g, (_match, indexText) => escapeXmlTags(tokens[Number.parseInt(indexText, 10)] ?? ''))
+        .replaceAll('$ARGUMENTS', escapeXmlTags(rawArgs));
+    const hasArgumentPlaceholder = content !== body;
+    content = content
+        .replaceAll('${KIMI_SKILL_DIR}', skillDir)
+        .replaceAll('${KIMI_SESSION_ID}', sessionId ?? '');
+    if (!hasArgumentPlaceholder && rawArgs.length > 0) {
+        return `${content}\n\nARGUMENTS: ${escapeXmlTags(rawArgs)}`;
+    }
+    return content;
+}
+function toKimiPath(nativePath) {
+    const slashPath = nativePath.replaceAll('\\', '/');
+    return /^[a-z]:\//.test(slashPath)
+        ? slashPath[0].toUpperCase() + slashPath.slice(1)
+        : slashPath;
+}
+function loadProjectSkill(cwd, requestedName) {
+    const skillsRoot = node_path_1.default.resolve(cwd, '.kimi-code', 'skills');
+    const directDir = node_path_1.default.join(skillsRoot, requestedName);
+    let directError;
+    let mismatchedDirectName;
+    const loadCandidate = (skillDir) => {
+        const skillPath = node_path_1.default.join(skillDir, 'SKILL.md');
+        if (!(0, node_fs_1.existsSync)(skillPath))
+            return null;
+        try {
+            const document = parseKimiSkillDocument((0, node_fs_1.readFileSync)(skillPath, 'utf8'), skillPath);
+            if (document.metadataName.toLowerCase() === requestedName.toLowerCase()) {
+                // Kimi resolves each discovered skill root through fs.realpath before
+                // parsing SKILL.md. Match that behavior so `${KIMI_SKILL_DIR}` and the
+                // activation envelope are identical for Desktop framework symlinks.
+                return { document, skillDir: toKimiPath((0, node_fs_1.realpathSync)(skillDir)) };
+            }
+            if (skillDir === directDir)
+                mismatchedDirectName = document.metadataName;
+        }
+        catch (error) {
+            // Kimi discovery skips unrelated malformed entries. Preserve the exact
+            // direct candidate error so the requested broken skill remains
+            // actionable instead of being reported as generically missing.
+            if (skillDir === directDir) {
+                directError = error instanceof Error ? error : new Error(String(error));
+            }
+        }
+        return null;
+    };
+    const direct = loadCandidate(directDir);
+    if (direct)
+        return direct;
+    if ((0, node_fs_1.existsSync)(skillsRoot)) {
+        let entries;
+        try {
+            entries = (0, node_fs_1.readdirSync)(skillsRoot, { withFileTypes: true });
+        }
+        catch (error) {
+            throw new KimiSkillResolutionError(`Cannot scan Kimi skills at ${skillsRoot}: ` +
+                (error instanceof Error ? error.message : String(error)));
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory() && !entry.isSymbolicLink())
+                continue;
+            const candidate = node_path_1.default.join(skillsRoot, entry.name);
+            if (candidate === directDir)
+                continue;
+            const resolved = loadCandidate(candidate);
+            if (resolved)
+                return resolved;
+        }
+    }
+    if (directError)
+        throw directError;
+    if (mismatchedDirectName) {
+        throw new KimiSkillResolutionError(`Kimi skill directory "${requestedName}" declares name "${mismatchedDirectName}".`);
+    }
+    throw new KimiSkillResolutionError(`Kimi skill "${requestedName}" is not installed under ${skillsRoot}. ` +
+        'Run the SpecRails Core update for provider "kimi" before retrying.');
+}
+/**
+ * Resolve a provider/Core slash invocation into the same user-activated-skill
+ * prompt shape used by Kimi 0.27's `Session.activateSkill()` path.
+ */
+function formatKimiCoreCommand(command, cwd, sessionId) {
+    const invocation = parseInvocation(command);
+    if (!invocation)
+        return command;
+    if (!cwd) {
+        throw new KimiSkillResolutionError(`Cannot resolve Kimi skill "${invocation.skillName}" without a project working directory.`);
+    }
+    const { document, skillDir } = loadProjectSkill(cwd, invocation.skillName);
+    if (!document.body) {
+        throw new KimiSkillResolutionError(`Kimi skill "${invocation.skillName}" has an empty body.`);
+    }
+    const effectiveSessionId = sessionId?.trim() || undefined;
+    if (document.body.includes('${KIMI_SESSION_ID}') && !effectiveSessionId) {
+        throw new KimiSkillResolutionError(`Kimi skill "${document.metadataName}" requires \${KIMI_SESSION_ID}, ` +
+            'which is unavailable before a fresh `kimi -p` session emits its resume hint.');
+    }
+    const renderedName = document.metadataName;
+    const skillContent = expandSkillParameters(document.body, invocation.rawArgs, skillDir, document.argumentNames, effectiveSessionId);
+    return [
+        `User activated the skill "${escapeXml(renderedName)}". Follow the loaded skill instructions.`,
+        '',
+        `<kimi-skill-loaded name="${escapeXml(renderedName)}" trigger="user-slash" source="project" ` +
+            `dir="${escapeXml(skillDir)}" args="${escapeXml(invocation.rawArgs)}">`,
+        skillContent,
+        '</kimi-skill-loaded>',
+    ].join('\n');
+}
+exports._test = {
+    parseInvocation,
+    parseSkillDocument: parseKimiSkillDocument,
+    expandSkillParameters,
+    tokenizeArgs,
+    toKimiPath,
+};