@rpamis/comet 0.3.9 → 0.4.0-beta.2

package/dist/domains/skill/platform-install.d.ts

@@ -0,0 +1,79 @@
+import { type Platform } from '../../platform/install/platforms.js';
+import type { InstallScope, InstallMode } from '../../platform/install/types.js';
+import type { LanguageConfig, SkillLanguageId } from './languages.js';
+type HookConfig = {
+    matcher: string;
+    description: string;
+};
+type Manifest = {
+    version: string;
+    skills: string[];
+    internalSkills?: string[];
+    rules?: string[];
+    hooks?: Record<string, HookConfig>;
+    languages?: LanguageConfig[];
+};
+interface PlannedSkillSourceFile {
+    relativePath: string;
+    source: string;
+}
+interface PlannedSkillFile {
+    source: string;
+    destination: string;
+}
+declare function planSkillDirectoryCopy(files: readonly PlannedSkillSourceFile[], destinationRoot: string): PlannedSkillFile[];
+declare function getManagedSkillPaths(manifest: Manifest): string[];
+declare function getUserFacingSkillNames(manifest: Manifest): string[];
+declare function getAssetsDir(): string;
+/**
+ * Get the central skills directory for symlink mode.
+ * Project scope: <project>/.comet/skills/
+ * Global scope: ~/.comet/skills/
+ */
+declare function getCentralSkillsDir(baseDir: string, _scope: InstallScope): string;
+/**
+ * Install skills using symlink mode:
+ * 1. Copy skills to central store (.comet/skills/)
+ * 2. Create symlink from platform dir to central store
+ */
+declare function installSkillsAsSymlink(baseDir: string, platform: Platform, overwrite: boolean, languageSkillsDir?: string, scope?: InstallScope): Promise<{
+    copied: number;
+    skipped: number;
+    failed: number;
+}>;
+declare function copyCometSkillsForPlatform(baseDir: string, platform: Platform, overwrite: boolean, languageSkillsDir?: string, scope?: InstallScope, installMode?: InstallMode): Promise<{
+    copied: number;
+    skipped: number;
+    failed: number;
+}>;
+declare function readManifest(): Promise<Manifest>;
+declare function getManifestSkills(): Promise<string[]>;
+declare function copyCometRulesForPlatform(baseDir: string, platform: Platform, overwrite: boolean, languageId: SkillLanguageId, scope?: InstallScope): Promise<{
+    copied: number;
+    skipped: number;
+}>;
+declare function computeRuleDestPath(rulesDestDir: string, ruleFileName: string, rulesFormat: string): string;
+declare function formatRuleContent(content: string, ruleFileName: string, rulesFormat: string): string;
+/**
+ * Install Comet hooks for platforms that support them.
+ * Supports multiple hook formats:
+ *   'claude-code' — settings.local.json with PreToolUse array (Claude Code, Codex, Amazon Q)
+ *   'qwen' — settings.json with PreToolUse/hooks array (Qwen Code)
+ *   'qoder' — settings.json with PreToolUse/hooks array (Qoder)
+ *   'gemini' — settings.json with hooks.BeforeTool array (Gemini CLI)
+ *   'windsurf' — hooks.json with pre_write_code array
+ *   'copilot' — hooks/*.json with preToolUse
+ *   'kiro' — hooks/*.kiro.hook JSON files
+ */
+declare function installCometHooksForPlatform(baseDir: string, platform: Platform, scope?: InstallScope): Promise<{
+    installed: boolean;
+    reason?: string;
+}>;
+declare function isManagedHookCommand(command: unknown, scriptRelPaths: string[]): boolean;
+declare function parseProjectConfigOverrides(content: string): Record<string, string>;
+declare function renderProjectConfig(existing: Record<string, string>, language?: string): string;
+declare function mergeProjectConfig(projectPath: string, language?: string): Promise<void>;
+declare function createWorkingDirs(projectPath: string, language?: string): Promise<void>;
+export { copyCometSkillsForPlatform, copyCometRulesForPlatform, installCometHooksForPlatform, readManifest, getManagedSkillPaths, getManifestSkills, getUserFacingSkillNames, createWorkingDirs, getAssetsDir, computeRuleDestPath, formatRuleContent, isManagedHookCommand, planSkillDirectoryCopy, mergeProjectConfig, parseProjectConfigOverrides, renderProjectConfig, getCentralSkillsDir, installSkillsAsSymlink, };
+export type { Manifest, LanguageConfig, PlannedSkillFile, PlannedSkillSourceFile };
+//# sourceMappingURL=platform-install.d.ts.map

package/dist/domains/skill/platform-install.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"platform-install.d.ts","sourceRoot":"","sources":["../../../domains/skill/platform-install.ts"],"names":[],"mappings":"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"}

package/dist/{core/skills.js → domains/skill/platform-install.js}

@@ -1,19 +1,184 @@
 import path from 'path';
-import { readFile, writeFile } from 'fs/promises';
+import { existsSync } from 'fs';
+import { readFile, writeFile, lstat, unlink, symlink, rm, readdir } from 'fs/promises';
 import { fileURLToPath } from 'url';
-import { fileExists, readJson, copyFile, ensureDir } from '../utils/file-system.js';
-import { getPlatformSkillsDir } from './platforms.js';
+import { parseDocument } from 'yaml';
+import { fileExists, readJson, copyFile, ensureDir } from '../../platform/fs/file-system.js';
+import { getPlatformSkillsDir } from '../../platform/install/platforms.js';
+import { formatSupportedArtifactLanguages, resolveArtifactLanguage } from './languages.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
+function planSkillDirectoryCopy(files, destinationRoot) {
+    return files
+        .map((file) => ({
+        source: file.source,
+        destination: path.join(destinationRoot, ...file.relativePath.split('/')),
+    }))
+        .sort((left, right) => left.destination < right.destination ? -1 : left.destination > right.destination ? 1 : 0);
+}
+function getManagedSkillPaths(manifest) {
+    return [...new Set([...manifest.skills, ...(manifest.internalSkills ?? [])])];
+}
+function getUserFacingSkillNames(manifest) {
+    return getTopLevelSkillNames(manifest.skills);
+}
+function getManagedSkillReplacementPaths(manifest) {
+    const allowed = new Set();
+    for (const skillPath of getManagedSkillPaths(manifest)) {
+        const parts = skillPath.split('/').filter(Boolean);
+        for (let depth = 1; depth <= parts.length; depth++) {
+            allowed.add(parts.slice(0, depth).join('/'));
+        }
+    }
+    return allowed;
+}
+async function collectDirectoryEntryPaths(root, current = root) {
+    const entries = await readdir(current, { withFileTypes: true });
+    const paths = [];
+    for (const entry of entries) {
+        const fullPath = path.join(current, entry.name);
+        const relativePath = path.relative(root, fullPath).split(path.sep).join('/');
+        paths.push(relativePath);
+        if (entry.isDirectory() && !entry.isSymbolicLink()) {
+            paths.push(...(await collectDirectoryEntryPaths(root, fullPath)));
+        }
+    }
+    return paths;
+}
+async function assertDirectoryContainsOnlyManagedEntries(dirPath, managedEntries) {
+    const entries = await collectDirectoryEntryPaths(dirPath);
+    const unmanagedEntries = entries.filter((entry) => !managedEntries.has(entry));
+    if (unmanagedEntries.length === 0)
+        return;
+    const preview = unmanagedEntries.slice(0, 5).join(', ');
+    const suffix = unmanagedEntries.length > 5 ? `, and ${unmanagedEntries.length - 5} more` : '';
+    throw new Error(`Refusing to replace ${dirPath} with a symlink because it contains unmanaged entries: ${preview}${suffix}. Move them aside or use copy install mode.`);
+}
 const OPENCODE_COMMAND_HEADER = `---
 description: Run the {skillName} Comet workflow
 ---
 `;
 const PI_COMMAND_EXTENSION_FILE = 'comet-commands.ts';
+const OPENCODE_STYLE_PLATFORM_IDS = new Set(['opencode', 'mimocode']);
 function getAssetsDir() {
-    return path.resolve(__dirname, '..', '..', 'assets');
+    const directAssets = path.resolve(__dirname, '..', '..', 'assets');
+    if (existsSync(path.join(directAssets, 'manifest.json'))) {
+        return directAssets;
+    }
+    const packageRootAssets = path.resolve(__dirname, '..', '..', '..', 'assets');
+    if (existsSync(path.join(packageRootAssets, 'manifest.json'))) {
+        return packageRootAssets;
+    }
+    return directAssets;
+}
+/**
+ * Get the central skills directory for symlink mode.
+ * Project scope: <project>/.comet/skills/
+ * Global scope: ~/.comet/skills/
+ */
+function getCentralSkillsDir(baseDir, _scope) {
+    return path.join(baseDir, '.comet', 'skills');
+}
+/**
+ * Create a symlink from linkPath pointing to target.
+ * On Windows, uses 'junction' type for directory symlinks (no admin required).
+ */
+async function createSymlink(target, linkPath, managedEntries) {
+    await ensureDir(path.dirname(linkPath));
+    // Remove existing link/directory if present
+    let stat = null;
+    try {
+        stat = await lstat(linkPath);
+    }
+    catch (err) {
+        if (err.code !== 'ENOENT') {
+            throw err;
+        }
+    }
+    if (stat?.isSymbolicLink()) {
+        await unlink(linkPath);
+    }
+    else if (stat?.isDirectory()) {
+        // For directories, try unlink first (handles Windows junctions)
+        try {
+            await unlink(linkPath);
+        }
+        catch {
+            await assertDirectoryContainsOnlyManagedEntries(linkPath, managedEntries);
+            await rm(linkPath, { recursive: true, force: true });
+        }
+    }
+    // Windows uses 'junction' for directory symlinks (no admin privileges required)
+    const type = process.platform === 'win32' ? 'junction' : 'dir';
+    await symlink(target, linkPath, type);
+}
+/**
+ * Install skills using symlink mode:
+ * 1. Copy skills to central store (.comet/skills/)
+ * 2. Create symlink from platform dir to central store
+ */
+async function installSkillsAsSymlink(baseDir, platform, overwrite, languageSkillsDir = 'skills', scope = 'project') {
+    const centralDir = getCentralSkillsDir(baseDir, scope);
+    const assetsDir = getAssetsDir();
+    const manifestPath = path.join(assetsDir, 'manifest.json');
+    if (!(await fileExists(manifestPath))) {
+        throw new Error(`Manifest not found at ${manifestPath}`);
+    }
+    const manifest = await readJson(manifestPath);
+    if (!manifest || !Array.isArray(manifest.skills)) {
+        throw new Error(`Invalid manifest at ${manifestPath}: "skills" must be an array`);
+    }
+    const managedSkillReplacementPaths = getManagedSkillReplacementPaths(manifest);
+    // Step 1: Copy skills to central store
+    let copied = 0;
+    let skippedCount = 0;
+    let failedCount = 0;
+    for (const skillRelPath of getManagedSkillPaths(manifest)) {
+        const isScript = skillRelPath.includes('/scripts/');
+        const sourceDir = isScript ? 'skills' : languageSkillsDir;
+        const src = path.join(assetsDir, sourceDir, skillRelPath);
+        const centralDest = path.join(centralDir, 'skills', skillRelPath);
+        if (!overwrite && (await fileExists(centralDest))) {
+            skippedCount++;
+            continue;
+        }
+        try {
+            await copyFile(src, centralDest);
+            copied++;
+        }
+        catch (err) {
+            failedCount++;
+            console.error(`    Failed to copy ${skillRelPath} to central store: ${err.message}`);
+        }
+    }
+    // Step 2: Create symlink from platform dir to central store
+    const platformSkillsDir = path.join(baseDir, getPlatformSkillsDir(platform, scope), 'skills');
+    const centralSkillsDir = path.join(centralDir, 'skills');
+    try {
+        await createSymlink(centralSkillsDir, platformSkillsDir, managedSkillReplacementPaths);
+    }
+    catch (err) {
+        failedCount++;
+        console.error(`    Failed to create symlink ${platformSkillsDir} -> ${centralSkillsDir}: ${err.message}`);
+    }
+    // Handle OpenCode-style platform commands (still need copy, as command content may differ)
+    if (OPENCODE_STYLE_PLATFORM_IDS.has(platform.id)) {
+        const result = await createOpenCodeCommands(baseDir, platform, manifest.skills, overwrite, scope, languageSkillsDir);
+        copied += result.copied;
+        skippedCount += result.skipped;
+    }
+    // Handle Pi platform command extension
+    if (platform.id === 'pi') {
+        const result = await createPiCommandExtension(baseDir, platform, manifest.skills, overwrite, scope);
+        copied += result.copied;
+        skippedCount += result.skipped;
+    }
+    return { copied, skipped: skippedCount, failed: failedCount };
 }
-async function copyCometSkillsForPlatform(baseDir, platform, overwrite, languageSkillsDir = 'skills', scope = 'project') {
+async function copyCometSkillsForPlatform(baseDir, platform, overwrite, languageSkillsDir = 'skills', scope = 'project', installMode = 'copy') {
+    if (installMode === 'symlink') {
+        return installSkillsAsSymlink(baseDir, platform, overwrite, languageSkillsDir, scope);
+    }
     const assetsDir = getAssetsDir();
     const manifestPath = path.join(assetsDir, 'manifest.json');
     if (!(await fileExists(manifestPath))) {
@@ -25,7 +190,8 @@ async function copyCometSkillsForPlatform(baseDir, platform, overwrite, language
     }
     let copied = 0;
     let skippedCount = 0;
-    for (const skillRelPath of manifest.skills) {
+    let failedCount = 0;
+    for (const skillRelPath of getManagedSkillPaths(manifest)) {
         const isScript = skillRelPath.includes('/scripts/');
         const sourceDir = isScript ? 'skills' : languageSkillsDir;
         const src = path.join(assetsDir, sourceDir, skillRelPath);
@@ -39,10 +205,15 @@ async function copyCometSkillsForPlatform(baseDir, platform, overwrite, language
             copied++;
         }
         catch (err) {
+            // Surface the failure via the returned `failed` count instead of
+            // swallowing it, so a half-installed state (e.g. a missing
+            // comet-hook-guard.mjs) is visible in the summary rather than silently
+            // breaking phase guard downstream.
+            failedCount++;
             console.error(`    Failed to copy ${skillRelPath}: ${err.message}`);
         }
     }
-    if (platform.id === 'opencode') {
+    if (OPENCODE_STYLE_PLATFORM_IDS.has(platform.id)) {
         const result = await createOpenCodeCommands(baseDir, platform, manifest.skills, overwrite, scope, languageSkillsDir);
         copied += result.copied;
         skippedCount += result.skipped;
@@ -52,7 +223,7 @@ async function copyCometSkillsForPlatform(baseDir, platform, overwrite, language
         copied += result.copied;
         skippedCount += result.skipped;
     }
-    return { copied, skipped: skippedCount };
+    return { copied, skipped: skippedCount, failed: failedCount };
 }
 function getTopLevelSkillNames(skillPaths) {
     return skillPaths.flatMap((skillPath) => {
@@ -168,7 +339,7 @@ async function readManifest() {
 }
 async function getManifestSkills() {
     const manifest = await readManifest();
-    return manifest.skills;
+    return getManagedSkillPaths(manifest);
 }
 /**
  * Copy Comet rule files to a platform's rules directory.
@@ -178,12 +349,38 @@ async function getManifestSkills() {
  *   'copilot' = GitHub Copilot .instructions.md with applyTo frontmatter
  * Skips platforms without rulesDir.
  */
-async function copyCometRulesForPlatform(baseDir, platform, overwrite, scope = 'project') {
+// Rule variants share a base name and differ only by a `.en.md` suffix
+// (e.g. `comet-phase-guard.md` = zh default, `comet-phase-guard.en.md` = en).
+// Centralized here so the naming convention only needs to change in one place.
+const EN_RULE_SUFFIX = /\.en\.md$/;
+function isEnglishRuleVariant(ruleRelPath) {
+    return EN_RULE_SUFFIX.test(ruleRelPath);
+}
+function toRuleBaseName(ruleRelPath) {
+    return ruleRelPath.replace(EN_RULE_SUFFIX, '.md');
+}
+// Pick exactly one variant per base name for the requested language, falling
+// back to whichever variant exists if there's no per-language pair.
+function selectRulePathsForLanguage(rulePaths, languageId) {
+    const wantEnglish = languageId === 'en';
+    const selected = new Map();
+    for (const rulePath of rulePaths) {
+        const isEnglishVariant = isEnglishRuleVariant(rulePath);
+        const baseKey = toRuleBaseName(rulePath);
+        const matched = isEnglishVariant === wantEnglish;
+        const existing = selected.get(baseKey);
+        if (!existing || (matched && !existing.matched)) {
+            selected.set(baseKey, { rulePath, matched });
+        }
+    }
+    return [...selected.values()].map((entry) => entry.rulePath);
+}
+async function copyCometRulesForPlatform(baseDir, platform, overwrite, languageId, scope = 'project') {
     if (!platform.rulesDir || !platform.rulesFormat) {
         return { copied: 0, skipped: 0 };
     }
     const manifest = await readManifest();
-    const rulePaths = manifest.rules;
+    const rulePaths = selectRulePathsForLanguage(manifest.rules ?? [], languageId);
     if (!rulePaths || rulePaths.length === 0) {
         return { copied: 0, skipped: 0 };
     }
@@ -203,7 +400,9 @@ async function copyCometRulesForPlatform(baseDir, platform, overwrite, scope = '
             console.error(`    Rule source not found: ${ruleRelPath}`);
             continue;
         }
-        const ruleFileName = path.basename(ruleRelPath);
+        // Normalize the `.en` infix away so the installed file name is the same
+        // regardless of which language variant was selected.
+        const ruleFileName = toRuleBaseName(path.basename(ruleRelPath));
         const rulesDestDir = path.join(rulesBase, platform.rulesDir);
         const dest = computeRuleDestPath(rulesDestDir, ruleFileName, platform.rulesFormat);
         if (!overwrite && (await fileExists(dest))) {
@@ -281,18 +480,18 @@ async function installCometHooksForPlatform(baseDir, platform, scope = 'project'
     try {
         switch (hookFormat) {
             case 'claude-code':
-                return installClaudeCodeHooks(platformBase, skillsDir, hooksConfig);
+                return installClaudeCodeHooks(baseDir, platformBase, skillsDir, hooksConfig);
             case 'qwen':
             case 'qoder':
-                return installQwenStyleHooks(platformBase, skillsDir, hooksConfig, hookFormat);
+                return installQwenStyleHooks(baseDir, platformBase, skillsDir, hooksConfig, hookFormat);
             case 'gemini':
-                return installGeminiHooks(platformBase, skillsDir, hooksConfig);
+                return installGeminiHooks(baseDir, platformBase, skillsDir, hooksConfig);
             case 'windsurf':
-                return installWindsurfHooks(platformBase, skillsDir, hooksConfig);
+                return installWindsurfHooks(baseDir, platformBase, skillsDir, hooksConfig);
             case 'copilot':
-                return installCopilotHooks(platformBase, skillsDir, hooksConfig);
+                return installCopilotHooks(baseDir, platformBase, skillsDir, hooksConfig);
             case 'kiro':
-                return installKiroHooks(platformBase, skillsDir, hooksConfig);
+                return installKiroHooks(baseDir, platformBase, skillsDir, hooksConfig);
             default:
                 return { installed: false, reason: `unsupported hook format: ${hookFormat}` };
         }
@@ -301,20 +500,29 @@ async function installCometHooksForPlatform(baseDir, platform, scope = 'project'
         return { installed: false, reason: err.message };
     }
 }
-/** Build the command path for a hook script given its manifest rel path and skillsDir */
-function buildHookCommand(skillsDir, scriptRelPath) {
-    return `bash ${skillsDir}/skills/${scriptRelPath}`;
+function quoteCommandArg(value) {
+    return `"${value.replaceAll('\\', '/').replaceAll('"', '\\"')}"`;
+}
+/** Build a hook command that is stable even when the hook runner executes from a subdirectory. */
+function buildHookCommand(baseDir, skillsDir, scriptRelPath) {
+    const projectRoot = path.resolve(baseDir);
+    const scriptPath = path.join(projectRoot, skillsDir, 'skills', ...scriptRelPath.split('/'));
+    return `node ${quoteCommandArg(scriptPath)} --project-root ${quoteCommandArg(projectRoot)}`;
 }
 function isManagedHookCommand(command, scriptRelPaths) {
     if (typeof command !== 'string')
         return false;
+    // Match both the current `node .../comet-hook-guard.mjs` form and the legacy
+    // `bash .../comet-hook-guard.sh` form so uninstall also cleans up hooks
+    // written by older Comet releases. Compare basenames without extension.
     const commandPath = command
         .trim()
-        .match(/^bash\s+["']?([^"'\s]+)["']?(?:\s|$)/)?.[1]
+        .match(/^(?:node|bash|sh)\s+["']?([^"'\s]+)["']?(?:\s|$)/)?.[1]
         ?.replace(/\\/g, '/');
     if (!commandPath)
         return false;
-    return scriptRelPaths.some((scriptRelPath) => commandPath.endsWith(`/skills/${scriptRelPath.replace(/\\/g, '/')}`));
+    const normalize = (value) => value.replace(/\.(?:sh|mjs)$/u, '');
+    return scriptRelPaths.some((scriptRelPath) => normalize(commandPath).endsWith(`/skills/${normalize(scriptRelPath.replace(/\\/g, '/'))}`));
 }
 function mergeHookGroups(existingGroups, newGroups, scriptRelPaths) {
     const mergedGroups = existingGroups.flatMap((group) => {
@@ -348,12 +556,12 @@ function asHookGroup(value) {
  * Claude Code, Codex, Amazon Q format:
  * Writes to settings.local.json with { hooks: { PreToolUse: [...] } }
  */
-async function installClaudeCodeHooks(platformBase, skillsDir, hooksConfig) {
+async function installClaudeCodeHooks(baseDir, platformBase, skillsDir, hooksConfig) {
     const settingsPath = path.join(platformBase, 'settings.local.json');
     // Group by matcher so hooks sharing the same matcher are merged
     const matcherGroups = {};
     for (const [scriptRelPath, config] of Object.entries(hooksConfig)) {
-        const command = buildHookCommand(skillsDir, scriptRelPath);
+        const command = buildHookCommand(baseDir, skillsDir, scriptRelPath);
         if (!matcherGroups[config.matcher]) {
             matcherGroups[config.matcher] = [];
         }
@@ -381,7 +589,7 @@ async function installClaudeCodeHooks(platformBase, skillsDir, hooksConfig) {
  * Qwen Code / Qoder format:
  * Writes to settings.json with { hooks: { PreToolUse: [{ matcher, hooks: [{ type, command }] }] } }
  */
-async function installQwenStyleHooks(platformBase, skillsDir, hooksConfig, _hookFormat) {
+async function installQwenStyleHooks(baseDir, platformBase, skillsDir, hooksConfig, _hookFormat) {
     const settingsPath = path.join(platformBase, 'settings.json');
     // Group by matcher
     const matcherGroups = {};
@@ -391,7 +599,7 @@ async function installQwenStyleHooks(platformBase, skillsDir, hooksConfig, _hook
         }
         matcherGroups[config.matcher].push({
             type: 'command',
-            command: buildHookCommand(skillsDir, scriptRelPath),
+            command: buildHookCommand(baseDir, skillsDir, scriptRelPath),
             description: config.description,
         });
     }
@@ -420,7 +628,7 @@ async function installQwenStyleHooks(platformBase, skillsDir, hooksConfig, _hook
  * Gemini CLI format:
  * Writes to .gemini/settings.json with { hooks: { BeforeTool: [{ matcher, hooks: [{ type, command }] }] } }
  */
-async function installGeminiHooks(platformBase, skillsDir, hooksConfig) {
+async function installGeminiHooks(baseDir, platformBase, skillsDir, hooksConfig) {
     const settingsPath = path.join(platformBase, 'settings.json');
     const entries = [];
     for (const [scriptRelPath, config] of Object.entries(hooksConfig)) {
@@ -429,7 +637,7 @@ async function installGeminiHooks(platformBase, skillsDir, hooksConfig) {
             hooks: [
                 {
                     type: 'command',
-                    command: buildHookCommand(skillsDir, scriptRelPath),
+                    command: buildHookCommand(baseDir, skillsDir, scriptRelPath),
                     name: config.description,
                 },
             ],
@@ -456,12 +664,12 @@ async function installGeminiHooks(platformBase, skillsDir, hooksConfig) {
  * Windsurf format:
  * Writes to .windsurf/hooks.json with { hooks: { pre_write_code: [{ command }] } }
  */
-async function installWindsurfHooks(platformBase, skillsDir, hooksConfig) {
+async function installWindsurfHooks(baseDir, platformBase, skillsDir, hooksConfig) {
     const hooksPath = path.join(platformBase, 'hooks.json');
     const entries = [];
     for (const [scriptRelPath] of Object.entries(hooksConfig)) {
         entries.push({
-            command: buildHookCommand(skillsDir, scriptRelPath),
+            command: buildHookCommand(baseDir, skillsDir, scriptRelPath),
             show_output: true,
         });
     }
@@ -487,14 +695,14 @@ async function installWindsurfHooks(platformBase, skillsDir, hooksConfig) {
  * GitHub Copilot format:
  * Writes to .github/hooks/comet-guard.json with preToolUse hooks config.
  */
-async function installCopilotHooks(platformBase, skillsDir, hooksConfig) {
+async function installCopilotHooks(baseDir, platformBase, skillsDir, hooksConfig) {
     const hooksDir = path.join(platformBase, 'hooks');
     const hookFilePath = path.join(hooksDir, 'comet-guard.json');
     const scriptEntries = [];
     for (const [scriptRelPath] of Object.entries(hooksConfig)) {
-        const cmd = buildHookCommand(skillsDir, scriptRelPath);
-        // Script requires bash; PowerShell field wraps bash invocation for Windows
-        scriptEntries.push({ bash: cmd, powershell: `bash -c '${cmd}'` });
+        const cmd = buildHookCommand(baseDir, skillsDir, scriptRelPath);
+        // Hook runs through node on every platform; both fields use the same command
+        scriptEntries.push({ bash: cmd, powershell: cmd });
     }
     const hookConfig = {
         version: 1,
@@ -510,10 +718,10 @@ async function installCopilotHooks(platformBase, skillsDir, hooksConfig) {
  * Kiro format:
  * Writes to .kiro/hooks/comet-phase-guard.kiro.hook as a JSON file.
  */
-async function installKiroHooks(platformBase, skillsDir, hooksConfig) {
+async function installKiroHooks(baseDir, platformBase, skillsDir, hooksConfig) {
     const hooksDir = path.join(platformBase, 'hooks');
     for (const [scriptRelPath, config] of Object.entries(hooksConfig)) {
-        const hookFileName = path.basename(scriptRelPath).replace(/\.sh$/, '.kiro.hook');
+        const hookFileName = path.basename(scriptRelPath).replace(/\.mjs$/, '.kiro.hook');
         const hookFilePath = path.join(hooksDir, hookFileName);
         // Map Write|Edit matcher to Kiro's write tool category
         const toolName = config.matcher === 'Write|Edit' ? 'write' : '*';
@@ -528,7 +736,7 @@ async function installKiroHooks(platformBase, skillsDir, hooksConfig) {
             },
             then: {
                 type: 'runCommand',
-                command: buildHookCommand(skillsDir, scriptRelPath),
+                command: buildHookCommand(baseDir, skillsDir, scriptRelPath),
             },
         };
         await ensureDir(hooksDir);
@@ -536,7 +744,67 @@ async function installKiroHooks(platformBase, skillsDir, hooksConfig) {
     }
     return { installed: true };
 }
-async function createWorkingDirs(projectPath) {
+function managedConfigFields(language = 'en') {
+    const artifactLanguage = resolveArtifactLanguage(language);
+    return [
+        {
+            key: 'language',
+            def: artifactLanguage.id,
+            comment: `# language: ${formatSupportedArtifactLanguages()}`,
+        },
+        { key: 'context_compression', def: 'off', comment: '# context_compression: off | beta' },
+        { key: 'review_mode', def: 'standard', comment: '# review_mode: off | standard | thorough' },
+        { key: 'auto_transition', def: 'true', comment: '# auto_transition: true | false' },
+    ];
+}
+const MANAGED_CONFIG_FIELDS = managedConfigFields();
+function getManagedConfigFields(language = 'en') {
+    return language === 'en' ? MANAGED_CONFIG_FIELDS : managedConfigFields(language);
+}
+function parseProjectConfigOverrides(content) {
+    if (!content.trim())
+        return {};
+    const doc = parseDocument(content, { uniqueKeys: false });
+    if (doc.errors.length > 0)
+        return {};
+    const js = doc.toJS();
+    if (!js || typeof js !== 'object' || Array.isArray(js))
+        return {};
+    const out = {};
+    for (const [k, v] of Object.entries(js)) {
+        if (v === null || v === undefined)
+            continue;
+        if (typeof v === 'string' || typeof v === 'number' || typeof v === 'boolean') {
+            out[k] = String(v);
+        }
+    }
+    return out;
+}
+function renderProjectConfig(existing, language = 'en') {
+    const lines = [];
+    const fields = getManagedConfigFields(language);
+    const managed = new Set(fields.map((f) => f.key));
+    for (const f of fields) {
+        lines.push(f.comment);
+        lines.push(`${f.key}: ${existing[f.key] ?? f.def}`);
+    }
+    for (const [k, v] of Object.entries(existing)) {
+        if (!managed.has(k))
+            lines.push(`${k}: ${v}`);
+    }
+    lines.push('');
+    return lines.join('\n');
+}
+async function mergeProjectConfig(projectPath, language = 'en') {
+    const configPath = path.join(projectPath, '.comet', 'config.yaml');
+    let existing = {};
+    if (await fileExists(configPath)) {
+        existing = parseProjectConfigOverrides(await readFile(configPath, 'utf-8'));
+    }
+    await ensureDir(path.dirname(configPath));
+    await writeFile(configPath, renderProjectConfig(existing, language), 'utf-8');
+}
+async function createWorkingDirs(projectPath, language = 'en') {
     const dirs = [
         path.join(projectPath, 'docs', 'superpowers', 'specs'),
         path.join(projectPath, 'docs', 'superpowers', 'plans'),
@@ -545,18 +813,7 @@ async function createWorkingDirs(projectPath) {
     for (const dir of dirs) {
         await ensureDir(dir);
     }
-    const configPath = path.join(projectPath, '.comet', 'config.yaml');
-    if (!(await fileExists(configPath))) {
-        await writeFile(configPath, [
-            '# context_compression: off | beta',
-            'context_compression: off',
-            '# review_mode: off | standard | thorough',
-            'review_mode: off',
-            '# auto_transition: true | false',
-            'auto_transition: true',
-            '',
-        ].join('\n'), 'utf-8');
-    }
-}
-export { copyCometSkillsForPlatform, copyCometRulesForPlatform, installCometHooksForPlatform, readManifest, getManifestSkills, createWorkingDirs, getAssetsDir, computeRuleDestPath, isManagedHookCommand, };
-//# sourceMappingURL=skills.js.map
+    await mergeProjectConfig(projectPath, language);
+}
+export { copyCometSkillsForPlatform, copyCometRulesForPlatform, installCometHooksForPlatform, readManifest, getManagedSkillPaths, getManifestSkills, getUserFacingSkillNames, createWorkingDirs, getAssetsDir, computeRuleDestPath, formatRuleContent, isManagedHookCommand, planSkillDirectoryCopy, mergeProjectConfig, parseProjectConfigOverrides, renderProjectConfig, getCentralSkillsDir, installSkillsAsSymlink, };
+//# sourceMappingURL=platform-install.js.map