@rpamis/comet 0.4.0-beta.1 → 0.4.0-beta.11

package/dist/app/commands/init.js

@@ -3,28 +3,78 @@ import os from 'os';
 import { checkbox, select } from '@inquirer/prompts';
 import { platformSelectPrompt } from './platform-select-prompt.js';
 import { PLATFORMS, getPlatformSkillsDir, } from '../../platform/install/platforms.js';
+import { resolvePlatformTarget, } from '../../platform/install/platform-targets.js';
 import { detectPlatforms, hasSkills, getBaseDir, } from '../../platform/install/detect.js';
-import { copyCometSkillsForPlatform, copyCometRulesForPlatform, installCometHooksForPlatform, createWorkingDirs, } from '../../domains/skill/platform-install.js';
+import { readProjectRegistry, upsertProjectInstallation, } from '../../platform/install/project-registry.js';
+import { copyCometSkillsForPlatform, copyCometRulesForPlatform, installCometHooksForPlatform, createWorkingDirs, mergeProjectConfig, prepareNativeSkillInstallTarget, } from '../../domains/skill/platform-install.js';
+import { installCometProjectInstructions } from '../../domains/skill/project-instructions.js';
 import { LANGUAGES } from '../../domains/skill/languages.js';
+import { resolveInitWorkflow } from '../../domains/comet-entry/init-workflow.js';
+import { migrateLegacyClassicSelection } from '../../domains/comet-entry/current-selection.js';
+import { defaultProjectConfig } from '../../domains/comet-native/native-config.js';
+import { ensureNativeDirectories, nativeProjectPaths, } from '../../domains/comet-native/native-paths.js';
 import { installOpenSpec, isCommandAvailable } from '../../domains/integrations/openspec.js';
+import { assertClassicLayoutInitializationSafe, beginClassicLayoutInitialization, checkpointClassicLayoutInitialization, completeClassicLayoutInitialization, } from '../../domains/comet-classic/classic-layout-initialization.js';
+import { classicLayoutPaths } from '../../domains/comet-classic/classic-layout.js';
+import { assertClassicOpenSpecRootHealthy } from '../../domains/comet-classic/classic-openspec-root.js';
+import { readWorkflowProjectConfigDocument, readWorkflowProjectConfigSnapshot, } from '../../domains/workflow-contract/project-config-reader.js';
+import { writeWorkflowProjectConfig } from '../../domains/workflow-contract/project-config-writer.js';
 import { installSuperpowersForPlatforms } from '../../domains/integrations/superpowers.js';
-import { hasCodegraphProjectIndex, installCodegraph, resolveCodegraphCommand, } from '../../domains/integrations/codegraph.js';
+import { hasCodegraphProjectIndex, initializeCodegraphProject, inspectCodegraphIndex, installCodegraph, resolveCodegraphCommand, } from '../../domains/integrations/codegraph.js';
 import { printVersionInfo } from '../../platform/version/version.js';
+import { printCometBanner } from '../cli/comet-banner.js';
 import { t } from './i18n.js';
-const COMET_BANNER = [
-    `   ██████╗ ██████╗ ███╗   ███╗███████╗████████╗`,
-    `  ██╔════╝██╔═══██╗████╗ ████║██╔════╝╚══██╔══╝`,
-    `  ██║     ██║   ██║██╔████╔██║█████╗     ██║   `,
-    `  ██║     ██║   ██║██║╚██╔╝██║██╔══╝     ██║   `,
-    `  ╚██████╗╚██████╔╝██║ ╚═╝ ██║███████╗   ██║   `,
-    `   ╚═════╝ ╚═════╝ ╚═╝     ╚═╝╚══════╝   ╚═╝   `,
-    `       Agent Skill Harness Phase-Guarded Automation`,
-    `               From Idea To Archive                `,
-].join('\n');
+import { detectInstalledCometTargets } from './update.js';
+function workflowChoiceNames(lang) {
+    if (lang === 'zh') {
+        return [
+            {
+                name: 'Native — 面向强模型的轻量自主流程，自带澄清、状态、检查与自动推进，不依赖外部 Skill',
+                value: 'native',
+            },
+            {
+                name: 'Classic — 面向高约束或较弱模型的完整 Spec/TDD 阶段流程，使用 OpenSpec 与 Superpowers',
+                value: 'classic',
+            },
+            {
+                name: '两者 — 同时安装两套独立入口；/comet 默认使用 Native，也可显式进入 Classic',
+                value: 'both',
+            },
+        ];
+    }
+    return [
+        {
+            name: 'Native — lightweight autonomy for strong models, with clarification, state, checks, and auto-progression; no external skills',
+            value: 'native',
+        },
+        {
+            name: 'Classic — full Spec/TDD phases for high-control work or weaker models, using OpenSpec and Superpowers',
+            value: 'classic',
+        },
+        {
+            name: 'Both — install two independent entries; /comet defaults to Native and Classic remains explicit',
+            value: 'both',
+        },
+    ];
+}
+async function selectWorkflow(options, lang, suggested) {
+    if (options.workflow)
+        return options.workflow;
+    if (options.yes || options.json)
+        return suggested;
+    return select({
+        message: lang === 'zh' ? '选择要初始化的 Comet 模式：' : 'Select Comet workflow(s):',
+        choices: workflowChoiceNames(lang),
+        default: suggested,
+    });
+}
+function includesWorkflow(selection, workflow) {
+    return selection === 'both' || selection === workflow;
+}
 async function selectScope(options, lang) {
     if (options.scope)
         return options.scope;
-    if (options.yes)
+    if (options.yes || options.json)
         return 'project';
     return select({
         message: t(lang, 'installScope'),
@@ -38,7 +88,7 @@ async function selectLanguage(options) {
     if (options.language) {
         return LANGUAGES.find((l) => l.id === options.language) ?? LANGUAGES[0];
     }
-    if (options.yes)
+    if (options.yes || options.json)
         return LANGUAGES[0];
     const langId = await select({
         message: t('en', 'languagePrompt'),
@@ -49,7 +99,7 @@ async function selectLanguage(options) {
 async function selectInstallMode(options, lang) {
     if (options.installMode)
         return options.installMode;
-    if (options.yes)
+    if (options.yes || options.json)
         return 'copy';
     return select({
         message: t(lang, 'installMode'),
@@ -66,7 +116,7 @@ async function selectPlatforms(detected, options, lang) {
         value: p.id,
         checked: detected.has(p.id),
     }));
-    if (options.yes) {
+    if (options.yes || options.json) {
         const selected = [...detected];
         return selected.length > 0 ? selected : PLATFORMS.map((p) => p.id);
     }
@@ -115,11 +165,18 @@ function resolveAction(hasExisting, options) {
         return 'overwrite';
     if (options.skipExisting)
         return 'skip';
-    if (options.yes)
+    if (options.yes || options.json)
         return 'skip';
     return 'install';
 }
-async function selectNpmDeps(projectPath, spPlatformIds, options, lang) {
+function resolveCometAction(hasExisting, options) {
+    if (hasExisting && (options.yes || options.json) && !options.overwrite && !options.skipExisting)
+        return 'reuse';
+    return resolveAction(hasExisting, options);
+}
+async function selectNpmDeps(projectPath, spPlatformIds, options, lang, workflow) {
+    if (workflow === 'native')
+        return new Set();
     const openSpecInstalled = isCommandAvailable('openspec');
     const codegraphInstalled = hasCodegraphProjectIndex(projectPath) || resolveCodegraphCommand() !== null;
     const superpowersInstalled = spPlatformIds.length === 0 ? true : undefined;
@@ -147,7 +204,7 @@ async function selectNpmDeps(projectPath, spPlatformIds, options, lang) {
         }
         return choice;
     });
-    if (options.yes) {
+    if (options.yes || options.json) {
         return new Set(states.filter((s) => !s.installed).map((s) => s.id));
     }
     const selected = await checkbox({
@@ -174,7 +231,7 @@ function isAllSkipped(r) {
         r.comet === 'skipped' &&
         r.codegraph === 'skipped');
 }
-function displaySummary(results, scope, lang) {
+function displaySummary(results, scope, lang, workflowSelection, nativeArtifactRoot, classicArtifactLayout) {
     const scopeLabel = scope === 'global' ? os.homedir() : 'project';
     const componentStatuses = [
         ['openspec', 'OpenSpec'],
@@ -186,12 +243,13 @@ function displaySummary(results, scope, lang) {
         .filter(([key]) => result[key] === 'failed')
         .map(([, label]) => `${label} ${t(lang, 'failedStatus')}`)
         .join(', ');
-    console.log(`\n  ${t(lang, 'setupComplete')} (scope: ${scopeLabel})\n`);
     // A platform with both installed and failed components is shown as failed,
     // not both. Use priority: failed > installed > skipped.
     const failed = results.filter(hasFailure);
     const installed = results.filter((r) => !hasFailure(r) && hasInstall(r));
     const skipped = results.filter(isAllSkipped);
+    const failures = results.flatMap((result) => result.failures);
+    console.log(`\n  ${failures.length > 0 ? (lang === 'zh' ? 'Comet 设置未完成。' : 'Comet setup incomplete.') : t(lang, 'setupComplete')} (scope: ${scopeLabel})\n`);
     if (installed.length > 0) {
         console.log(`  ${t(lang, 'installed')}`);
         for (const r of installed) {
@@ -205,20 +263,41 @@ function displaySummary(results, scope, lang) {
         console.log(`  ${t(lang, 'failedLabel')}`);
         for (const r of failed) {
             console.log(`    ${r.platform.name} (${failedDetails(r)})`);
+            for (const failure of r.failures) {
+                console.log(`      ${failure.component}: ${failure.reason}`);
+            }
         }
     }
-    if (scope === 'project') {
+    const showNativeWorkspace = scope === 'project' &&
+        includesWorkflow(workflowSelection, 'native') &&
+        nativeArtifactRoot !== null;
+    const showClassicWorkspace = scope === 'project' && includesWorkflow(workflowSelection, 'classic');
+    if (showNativeWorkspace || showClassicWorkspace) {
         console.log(`\n  ${t(lang, 'workingDirs')}`);
+        if (showNativeWorkspace) {
+            const root = nativeArtifactRoot === '.' ? '' : `${nativeArtifactRoot}/`;
+            console.log(`    ${t(lang, 'nativeWorkingDir')} ${root}comet/`);
+        }
+        if (showClassicWorkspace) {
+            const openSpecRoot = classicArtifactLayout === 'docs' ? 'docs/openspec/' : 'openspec/';
+            console.log(`    ${lang === 'zh' ? 'Classic：' : 'Classic: '}${openSpecRoot}`);
+            console.log('    Superpowers: docs/superpowers/specs/, docs/superpowers/plans/, docs/superpowers/reports/');
+        }
     }
-    console.log(`\n  ${t(lang, 'getStarted')}`);
-    console.log(`    ${t(lang, 'getStartedComet')}`);
-    console.log(`    ${t(lang, 'getStartedHotfix')}`);
-    console.log(`    ${t(lang, 'getStartedTweak')}\n`);
+    if (failures.length === 0) {
+        console.log(`\n  ${t(lang, 'getStarted')}`);
+        console.log(`    ${t(lang, 'getStartedComet')}`);
+        if (includesWorkflow(workflowSelection, 'classic')) {
+            console.log(`    ${t(lang, 'getStartedHotfix')}`);
+            console.log(`    ${t(lang, 'getStartedTweak')}`);
+        }
+    }
+    console.log();
 }
 export async function initCommand(targetPath, options = {}) {
     const projectPath = path.resolve(targetPath);
     const log = options.json ? () => undefined : console.log;
-    log(`\n${COMET_BANNER}\n`);
+    await printCometBanner({ enabled: !options.json });
     if (!options.json) {
         await printVersionInfo(log);
     }
@@ -227,33 +306,106 @@ export async function initCommand(targetPath, options = {}) {
     log(`  ${t(lang, 'settingUp')} ${projectPath}\n`);
     const detected = await detectPlatforms(projectPath);
     const scope = await selectScope(options, lang);
-    const installMode = await selectInstallMode(options, lang);
-    const selectedPlatformIds = await selectPlatforms(detected, options, lang);
-    if (selectedPlatformIds.length === 0) {
+    if (scope === 'global' && options.artifactRoot !== undefined) {
+        throw new Error('--root is only valid for project-scope initialization');
+    }
+    if (scope === 'global' && options.codegraph === 'init') {
+        throw new Error('--codegraph init is only valid for project-scope initialization');
+    }
+    if (scope === 'project') {
+        await readProjectRegistry({ strict: true });
+    }
+    const initialProjectConfigSnapshot = scope === 'project'
+        ? await readWorkflowProjectConfigSnapshot(projectPath, {
+            allowPartialProject: true,
+        })
+        : null;
+    const suggestedWorkflowDecision = scope === 'project'
+        ? await resolveInitWorkflow(projectPath, {
+            workflow: options.workflow === 'both' ? 'native' : options.workflow,
+            artifactRoot: options.artifactRoot,
+        }, initialProjectConfigSnapshot)
+        : null;
+    const configuredWorkflows = initialProjectConfigSnapshot?.document?.config?.workflows ?? [];
+    const suggestedWorkflowSelection = options.workflow === undefined &&
+        configuredWorkflows.includes('native') &&
+        configuredWorkflows.includes('classic')
+        ? 'both'
+        : (suggestedWorkflowDecision?.workflow ?? 'classic');
+    const workflowSelection = await selectWorkflow(options, lang, suggestedWorkflowSelection);
+    const workflow = workflowSelection === 'both' ? 'native' : workflowSelection;
+    const workflowDecision = scope === 'project'
+        ? options.workflow === undefined && (options.yes || options.json)
+            ? suggestedWorkflowDecision
+            : await resolveInitWorkflow(projectPath, {
+                workflow,
+                artifactRoot: options.artifactRoot,
+            }, initialProjectConfigSnapshot)
+        : null;
+    const initialProjectConfigDocument = initialProjectConfigSnapshot?.document ?? null;
+    const workflowSource = workflowDecision?.source ?? 'global-install';
+    const installMode = workflowSelection === 'native' ? 'copy' : await selectInstallMode(options, lang);
+    const selectedPlatformTargets = options.platform
+        ? [resolvePlatformTarget(options.platform, scope)]
+        : (await selectPlatforms(detected, options, lang)).map((platformId) => ({
+            platform: PLATFORMS.find((platform) => platform.id === platformId),
+            native: true,
+        }));
+    const selectedPlatformIds = selectedPlatformTargets.map((target) => target.platform.id);
+    if (selectedPlatformTargets.length === 0) {
         if (options.json) {
             console.log(JSON.stringify({
                 projectPath,
                 scope,
                 language: language.id,
+                workflow,
+                initializedWorkflows: workflowSelection === 'both' ? ['native', 'classic'] : [workflowSelection],
+                workflowSource,
+                projectConfigCreated: false,
+                projectConfigUpdated: false,
+                nativeArtifactRoot: null,
                 selectedPlatforms: [],
+                status: 'incomplete',
+                failures: [{ component: 'Comet', reason: 'no platforms selected' }],
                 results: [],
+                workingDirsCreated: false,
             }, null, 2));
-            return;
+            return { status: 'incomplete' };
         }
         log(`\n  ${t(lang, 'noPlatforms')}\n`);
-        return;
+        return { status: 'incomplete' };
     }
-    const selectedPlatforms = PLATFORMS.filter((p) => selectedPlatformIds.includes(p.id));
+    const selectedPlatforms = selectedPlatformTargets.map((target) => target.platform);
     const baseDir = getBaseDir(scope, projectPath);
     const plans = [];
-    for (const platform of selectedPlatforms) {
-        const hasOS = await hasSkills(baseDir, platform, 'openspec', selectedPlatforms, scope);
-        const hasSP = await hasSkills(baseDir, platform, 'superpowers', selectedPlatforms, scope);
-        const hasCM = await hasSkills(baseDir, platform, 'comet', selectedPlatforms, scope);
-        let osAction = resolveAction(hasOS, options);
-        let spAction = resolveAction(hasSP, options);
-        let cmAction = resolveAction(hasCM, options);
-        if (!options.yes) {
+    for (const target of selectedPlatformTargets) {
+        const { platform, native } = target;
+        const hasOS = native && includesWorkflow(workflowSelection, 'classic')
+            ? await hasSkills(baseDir, platform, 'openspec', selectedPlatforms, scope)
+            : false;
+        const hasSP = native && includesWorkflow(workflowSelection, 'classic')
+            ? await hasSkills(baseDir, platform, 'superpowers', selectedPlatforms, scope)
+            : false;
+        const hasCM = await hasSkills(baseDir, platform, 'comet', selectedPlatforms, scope, {
+            includeGlobalFallback: false,
+        });
+        let osAction = native && includesWorkflow(workflowSelection, 'classic')
+            ? resolveAction(hasOS, options)
+            : 'skip';
+        let spAction = native && includesWorkflow(workflowSelection, 'classic')
+            ? resolveAction(hasSP, options)
+            : 'skip';
+        let cmAction = workflowSelection === 'classic'
+            ? resolveCometAction(hasCM, options)
+            : resolveAction(hasCM, options);
+        if (includesWorkflow(workflowSelection, 'native') &&
+            hasCM &&
+            (options.yes || options.json) &&
+            !options.skipExisting &&
+            !options.overwrite) {
+            cmAction = 'install';
+        }
+        if (!options.yes && !options.json) {
             const existingComponents = [
                 hasOS && osAction === 'install' ? 'OpenSpec' : null,
                 hasSP && spAction === 'install' ? 'Superpowers' : null,
@@ -275,7 +427,13 @@ export async function initCommand(targetPath, options = {}) {
                 cmAction = await promptOverwriteChoice('Comet', platform.name, lang);
             }
         }
-        plans.push({ platform, osAction, spAction, cmAction, hasOS, hasSP, hasCM });
+        plans.push({ platform, native, osAction, spAction, cmAction, hasOS, hasSP, hasCM });
+    }
+    if (includesWorkflow(workflowSelection, 'native') && scope === 'project') {
+        for (const plan of plans) {
+            const action = plan.cmAction === 'overwrite' ? 'overwrite' : plan.cmAction === 'install' ? 'fill' : 'skip';
+            await prepareNativeSkillInstallTarget(baseDir, plan.platform, scope, language.skillsDir, action);
+        }
     }
     const osToolIds = Array.from(new Set(plans.filter((p) => p.osAction !== 'skip').map((p) => p.platform.openspecToolId)));
     const spPlatformIds = plans.filter((p) => p.spAction !== 'skip').map((p) => p.platform.id);
@@ -285,14 +443,65 @@ export async function initCommand(targetPath, options = {}) {
         .filter((p) => p.osAction !== 'skip')
         .map((p) => p.platform.id);
     const mirrorOpenCodePlatformIds = selectedPlatformIdsForOs.filter((id) => ['zcode', 'mimocode'].includes(id));
-    const selectedNpmDeps = await selectNpmDeps(projectPath, spPlatformIds, options, lang);
+    const selectedNpmDeps = await selectNpmDeps(projectPath, spPlatformIds, options, lang, includesWorkflow(workflowSelection, 'classic') ? 'classic' : 'native');
     const shouldInstallOpenSpecCli = selectedNpmDeps.has('openspec');
     const shouldInstallSuperpowers = selectedNpmDeps.has('superpowers');
     const shouldInstallCodegraphCli = selectedNpmDeps.has('codegraph');
+    const requiresClassicArtifactRoot = scope === 'project' &&
+        workflowDecision !== null &&
+        includesWorkflow(workflowSelection, 'classic');
     let osGlobalStatus = 'skipped';
-    if (osToolIds.length > 0) {
-        log(`\n  ${t(lang, 'installingOS')} ${osToolIds.join(', ')}`);
-        osGlobalStatus = await installOpenSpec(projectPath, osToolIds, scope, shouldInstallOpenSpecCli, mirrorOpenCodePlatformIds);
+    let osFailureReason;
+    let classicOpenSpecRootReady = !requiresClassicArtifactRoot;
+    let classicLayoutInitializationPermit;
+    if (requiresClassicArtifactRoot) {
+        try {
+            let initialization = await assertClassicLayoutInitializationSafe(projectPath, workflowDecision.classicArtifactLayout, undefined, initialProjectConfigSnapshot?.identity);
+            initialization = await beginClassicLayoutInitialization(projectPath, initialization);
+            classicLayoutInitializationPermit = initialization.initializationPermit;
+        }
+        catch (error) {
+            osGlobalStatus = 'failed';
+            osFailureReason = error.message;
+            log(`  Classic layout initialization: failed (${osFailureReason})`);
+        }
+    }
+    const assertClassicProjectMutationAllowed = scope === 'project' &&
+        workflowDecision &&
+        classicLayoutInitializationPermit &&
+        includesWorkflow(workflowSelection, 'classic')
+        ? async () => {
+            await assertClassicLayoutInitializationSafe(projectPath, workflowDecision.classicArtifactLayout, classicLayoutInitializationPermit);
+        }
+        : undefined;
+    if ((osToolIds.length > 0 || requiresClassicArtifactRoot) && !osFailureReason) {
+        log(`\n  ${t(lang, 'installingOS')} ${osToolIds.length > 0 ? osToolIds.join(', ') : 'artifact root'}`);
+        try {
+            osGlobalStatus = await installOpenSpec(projectPath, osToolIds, scope, shouldInstallOpenSpecCli, mirrorOpenCodePlatformIds, scope === 'project' ? workflowDecision?.classicArtifactLayout : 'legacy', assertClassicProjectMutationAllowed, (error) => {
+                osFailureReason = error.message;
+            });
+            if (osGlobalStatus === 'installed' && requiresClassicArtifactRoot) {
+                await assertClassicProjectMutationAllowed?.();
+                await assertClassicOpenSpecRootHealthy(projectPath, classicLayoutPaths(projectPath, workflowDecision.classicArtifactLayout));
+                await assertClassicProjectMutationAllowed?.();
+                if (classicLayoutInitializationPermit) {
+                    await checkpointClassicLayoutInitialization(projectPath, classicLayoutInitializationPermit);
+                }
+                classicOpenSpecRootReady = true;
+            }
+            else if (requiresClassicArtifactRoot) {
+                osFailureReason ??=
+                    osGlobalStatus === 'skipped'
+                        ? 'Classic OpenSpec artifact root initialization skipped because a compatible OpenSpec CLI is unavailable'
+                        : 'Classic OpenSpec artifact root initialization failed';
+                osGlobalStatus = 'failed';
+            }
+        }
+        catch (error) {
+            osGlobalStatus = 'failed';
+            osFailureReason = error.message;
+            log(`  OpenSpec: failed (${osFailureReason})`);
+        }
         if (osGlobalStatus === 'skipped' && !shouldInstallOpenSpecCli) {
             log(`  OpenSpec: ${t(lang, 'osSkippedNoCli')}`);
         }
@@ -318,72 +527,351 @@ export async function initCommand(targetPath, options = {}) {
         log(`\n  Superpowers: ${t(lang, 'allSkipped')}`);
     }
     const results = [];
+    let projectRouterInstalled = false;
     for (const plan of plans) {
         const { platform, cmAction } = plan;
         const platformSkillsDir = getPlatformSkillsDir(platform, scope);
         const skillsPath = installMode === 'symlink'
-            ? `.comet/skills/ -> ${platformSkillsDir}/skills/`
+            ? `via .comet/skills/ in ${platformSkillsDir}/skills/`
             : `${scope === 'global' ? '~/' : ''}${platformSkillsDir}/skills/`;
         let cmStatus = 'skipped';
+        const platformFailures = [];
+        let cometComponentInstalled = false;
+        let skillFailed = false;
         if (cmAction !== 'skip') {
-            const { copied, failed } = await copyCometSkillsForPlatform(baseDir, platform, cmAction === 'overwrite', language.skillsDir, scope, installMode);
+            const { copied, failed } = await copyCometSkillsForPlatform(baseDir, platform, cmAction === 'overwrite', language.skillsDir, scope, installMode, workflowSelection);
+            skillFailed = failed > 0;
             cmStatus = failed > 0 ? 'failed' : copied > 0 ? 'installed' : 'skipped';
-            log(`  Comet -> ${platform.name}: ${cmStatus} (${copied} files${failed > 0 ? `, ${failed} failed` : ''}) -> ${skillsPath}`);
+            cometComponentInstalled = copied > 0;
+            if (failed > 0) {
+                platformFailures.push({
+                    platform: platform.id,
+                    platformName: platform.name,
+                    component: 'Comet',
+                    reason: `${failed} Skill file(s) failed to install`,
+                });
+            }
+            if (cmAction === 'reuse' && copied === 0 && failed === 0) {
+                log(`  Comet -> ${platform.name}: reused (${t(lang, 'alreadyExists')})`);
+            }
+            else {
+                log(`  Comet -> ${platform.name}: ${cmStatus} (${copied} files${failed > 0 ? `, ${failed} failed` : ''}) -> ${skillsPath}`);
+            }
         }
         else {
             log(`  Comet -> ${platform.name}: skipped (${t(lang, 'alreadyExists')})`);
         }
-        if (cmAction !== 'skip') {
-            const { copied: ruleCopied } = await copyCometRulesForPlatform(baseDir, platform, cmAction === 'overwrite', scope);
-            if (ruleCopied > 0) {
-                log(`  Comet rules -> ${platform.name}: ${ruleCopied} ${t(lang, 'rulesInstalled')}`);
+        if (cmAction !== 'skip' && !skillFailed) {
+            try {
+                const { copied: ruleCopied, failed: ruleFailed } = await copyCometRulesForPlatform(baseDir, platform, cmAction === 'overwrite', language.id, scope, workflowSelection);
+                cometComponentInstalled ||= ruleCopied > 0;
+                if (ruleCopied > 0) {
+                    log(`  Comet rules -> ${platform.name}: ${ruleCopied} ${t(lang, 'rulesInstalled')}`);
+                }
+                if (ruleFailed > 0) {
+                    cmStatus = 'failed';
+                    platformFailures.push({
+                        platform: platform.id,
+                        platformName: platform.name,
+                        component: 'Rule',
+                        reason: `${ruleFailed} Rule file(s) failed to install`,
+                    });
+                    log(`  Comet rules -> ${platform.name}: ${t(lang, 'rulesFailed')} (${ruleFailed})`);
+                }
+            }
+            catch (err) {
+                cmStatus = 'failed';
+                platformFailures.push({
+                    platform: platform.id,
+                    platformName: platform.name,
+                    component: 'Rule',
+                    reason: err.message,
+                });
+                log(`  Comet rules -> ${platform.name}: ${t(lang, 'rulesFailed')} (${err.message})`);
             }
         }
-        if (cmAction !== 'skip' && platform.supportsHooks) {
-            const { installed, reason } = await installCometHooksForPlatform(baseDir, platform, scope);
-            if (installed) {
-                log(`  Comet hooks -> ${platform.name}: ${t(lang, 'hooksInstalled')}`);
+        if (cmAction !== 'skip' && !skillFailed) {
+            try {
+                const { status, reason, cleanupFailed = 0, } = await installCometHooksForPlatform(baseDir, platform, scope, workflowSelection);
+                cometComponentInstalled ||= status === 'installed';
+                if (status === 'installed') {
+                    if (scope === 'project')
+                        projectRouterInstalled = true;
+                    log(`  Comet hooks -> ${platform.name}: ${t(lang, 'hooksInstalled')}`);
+                    if (cleanupFailed > 0) {
+                        cmStatus = 'failed';
+                        platformFailures.push({
+                            platform: platform.id,
+                            platformName: platform.name,
+                            component: 'Hook',
+                            reason: reason ?? `legacy Hook cleanup failed (${cleanupFailed})`,
+                        });
+                        log(`  Comet hooks -> ${platform.name}: ${reason}`);
+                    }
+                }
+                else if (status === 'failed') {
+                    cmStatus = 'failed';
+                    platformFailures.push({
+                        platform: platform.id,
+                        platformName: platform.name,
+                        component: 'Hook',
+                        reason: reason ?? 'Hook installation failed',
+                    });
+                    log(`  Comet hooks -> ${platform.name}: ${t(lang, 'hooksFailed')} (${reason})`);
+                }
+                else if (reason && platform.supportsHooks) {
+                    log(`  Comet hooks -> ${platform.name}: ${t(lang, 'hooksSkipped')} (${reason})`);
+                }
             }
-            else if (reason) {
-                log(`  Comet hooks -> ${platform.name}: ${t(lang, 'hooksSkipped')} (${reason})`);
+            catch (err) {
+                cmStatus = 'failed';
+                platformFailures.push({
+                    platform: platform.id,
+                    platformName: platform.name,
+                    component: 'Hook',
+                    reason: err.message,
+                });
+                log(`  Comet hooks -> ${platform.name}: ${t(lang, 'hooksFailed')} (${err.message})`);
             }
         }
+        if (cmAction !== 'skip' && cmStatus !== 'failed') {
+            cmStatus = cometComponentInstalled ? 'installed' : 'skipped';
+        }
         results.push({
             platform,
-            openspec: osToolIds.includes(platform.openspecToolId) ? osGlobalStatus : 'skipped',
+            openspec: osToolIds.includes(platform.openspecToolId) || requiresClassicArtifactRoot
+                ? osGlobalStatus
+                : 'skipped',
             superpowers: plan.spAction !== 'skip' ? spGlobalStatus : 'skipped',
             comet: cmStatus,
             codegraph: 'skipped',
+            failures: [
+                ...((osToolIds.includes(platform.openspecToolId) || requiresClassicArtifactRoot) &&
+                    osGlobalStatus === 'failed'
+                    ? [
+                        {
+                            platform: platform.id,
+                            platformName: platform.name,
+                            component: 'OpenSpec',
+                            reason: osFailureReason ??
+                                'OpenSpec installation failed; see the preceding diagnostic for details',
+                        },
+                    ]
+                    : []),
+                ...(plan.spAction !== 'skip' && spGlobalStatus === 'failed'
+                    ? [
+                        {
+                            platform: platform.id,
+                            platformName: platform.name,
+                            component: 'Superpowers',
+                            reason: 'Superpowers installation failed; see the preceding diagnostic for details',
+                        },
+                    ]
+                    : []),
+                ...platformFailures,
+            ],
         });
     }
     const codegraphAlreadyIndexed = hasCodegraphProjectIndex(projectPath);
-    // JSON mode never installs CodeGraph interactively (matches pre-i18n behavior).
-    // If the project already has a .codegraph/ index, skip.
-    // Otherwise, only install when the user selected codegraph in the npm-deps prompt.
-    const shouldInstallCodegraph = !options.json && !codegraphAlreadyIndexed && shouldInstallCodegraphCli;
+    const shouldInstallCodegraph = options.codegraph === 'init' ||
+        (options.codegraph === undefined &&
+            !options.json &&
+            !codegraphAlreadyIndexed &&
+            shouldInstallCodegraphCli);
     if (shouldInstallCodegraph) {
         log(`\n  ${t(lang, 'installingCG')}`);
-        const cgGlobalStatus = await installCodegraph(projectPath, scope, true);
+        const cgGlobalStatus = options.codegraph === 'init'
+            ? await initializeCodegraphProject(projectPath, true, options.json === true)
+            : await installCodegraph(projectPath, scope, true, options.json === true);
         log(`  CodeGraph: ${cgGlobalStatus}`);
         for (const r of results) {
             r.codegraph = cgGlobalStatus;
+            if (cgGlobalStatus === 'failed') {
+                r.failures.push({
+                    platform: r.platform.id,
+                    platformName: r.platform.name,
+                    component: 'CodeGraph',
+                    reason: 'CodeGraph installation failed; see the preceding diagnostic for details',
+                });
+            }
         }
     }
-    else if (!options.json && codegraphAlreadyIndexed) {
+    else if (!options.json && options.codegraph !== 'skip' && codegraphAlreadyIndexed) {
         log('\n  CodeGraph: skipped (existing .codegraph index detected)');
     }
     else if (!options.json) {
         log(`\n  CodeGraph: ${t(lang, 'cgSkippedByUser')}`);
     }
-    if (scope === 'project') {
-        await createWorkingDirs(projectPath, language.artifactLanguage);
+    const codegraph = options.codegraph === 'skip'
+        ? {
+            requested: 'skip',
+            status: 'skipped',
+            repairable: false,
+            remediation: null,
+            detail: 'CodeGraph setup explicitly skipped',
+        }
+        : scope === 'project'
+            ? {
+                requested: options.codegraph ?? 'auto',
+                ...inspectCodegraphIndex(projectPath),
+            }
+            : {
+                requested: options.codegraph ?? 'auto',
+                status: resolveCodegraphCommand() ? 'cli_ready' : 'cli_missing',
+                repairable: false,
+                remediation: resolveCodegraphCommand()
+                    ? null
+                    : 'npm install -g @colbymchenry/codegraph',
+                detail: resolveCodegraphCommand()
+                    ? 'CodeGraph CLI is installed; project indexes are not part of global scope'
+                    : 'CodeGraph CLI is not installed',
+            };
+    let projectConfigCreated = false;
+    let projectConfigUpdated = false;
+    let nativeArtifactRoot = null;
+    let workingDirsCreated = false;
+    let finalizationFailure;
+    const cometInstallComplete = results.length > 0 && results.every((result) => result.comet !== 'failed');
+    const projectInitializationComplete = cometInstallComplete && classicOpenSpecRootReady;
+    if (scope === 'project' &&
+        projectRouterInstalled &&
+        projectInitializationComplete &&
+        includesWorkflow(workflowSelection, 'classic')) {
+        if (await migrateLegacyClassicSelection(projectPath)) {
+            log('  Comet current selection -> migrated Classic v1 to shared v2');
+        }
+    }
+    try {
+        if (scope === 'project' && workflowDecision && projectInitializationComplete) {
+            if (includesWorkflow(workflowSelection, 'native')) {
+                const paths = await nativeProjectPaths(projectPath, workflowDecision.artifactRoot);
+                await ensureNativeDirectories(paths);
+                nativeArtifactRoot = workflowDecision.artifactRoot;
+            }
+            if (includesWorkflow(workflowSelection, 'classic')) {
+                await createWorkingDirs(projectPath, language.artifactLanguage, workflowDecision.classicArtifactLayout, classicLayoutInitializationPermit);
+            }
+            workingDirsCreated = true;
+            if (includesWorkflow(workflowSelection, 'native')) {
+                await installCometProjectInstructions(projectPath, language.id);
+            }
+            const successfulCometPlatforms = new Set(results
+                .filter((result) => result.comet !== 'failed' &&
+                plans.some((plan) => plan.platform.id === result.platform.id && plan.cmAction !== 'skip'))
+                .map((result) => result.platform.id));
+            const completeProjectTargets = options.platform
+                ? (await Promise.all(plans
+                    .filter((plan) => plan.cmAction !== 'skip' && successfulCometPlatforms.has(plan.platform.id))
+                    .map(async (plan) => {
+                    if (plan.cmAction !== 'reuse') {
+                        return {
+                            platform: plan.platform,
+                            language: language.id,
+                        };
+                    }
+                    const existing = (await detectInstalledCometTargets(projectPath, {
+                        scopes: ['project'],
+                    })).find((target) => target.platform.id === plan.platform.id);
+                    return existing
+                        ? {
+                            platform: plan.platform,
+                            language: existing.language,
+                        }
+                        : null;
+                }))).filter((target) => Boolean(target))
+                : (await detectInstalledCometTargets(projectPath, {
+                    scopes: ['project'],
+                })).filter((target) => successfulCometPlatforms.has(target.platform.id));
+            if (completeProjectTargets.length > 0) {
+                await upsertProjectInstallation(projectPath, completeProjectTargets.map((target) => ({
+                    platform: target.platform.id,
+                    language: target.language,
+                })), 'init');
+            }
+            // The project config activates the selected workflow. Commit it only after
+            // every required project artifact has been written successfully so a
+            // partial initialization cannot route later commands into Native.
+            const existingDocument = await readWorkflowProjectConfigDocument(projectPath, {
+                allowPartialProject: true,
+            });
+            const existing = existingDocument?.config ?? null;
+            const selectedWorkflows = workflowSelection === 'both' ? ['native', 'classic'] : [workflowSelection];
+            {
+                const defaults = defaultProjectConfig(workflowDecision.artifactRoot, language.artifactLanguage);
+                const config = existing
+                    ? {
+                        ...existing,
+                        ...(existing.native ? { native: { ...existing.native } } : {}),
+                        ...(existing.classic ? { classic: { ...existing.classic } } : {}),
+                    }
+                    : {
+                        schema: 'comet.project.v1',
+                        default_workflow: workflowDecision.workflow,
+                        ambient_resume: existingDocument?.ambient_resume ?? true,
+                        ...(existingDocument?.classic ? { classic: { ...existingDocument.classic } } : {}),
+                    };
+                if (includesWorkflow(workflowSelection, 'native') && !config.native) {
+                    config.native = defaults.native;
+                }
+                config.default_workflow = workflowDecision.workflow;
+                config.workflows = [...selectedWorkflows];
+                if (includesWorkflow(workflowSelection, 'classic')) {
+                    config.classic = {
+                        ...config.classic,
+                        artifact_layout: workflowDecision.classicArtifactLayout,
+                        language: language.artifactLanguage,
+                        context_compression: config.classic?.context_compression ?? 'off',
+                        review_mode: config.classic?.review_mode ?? 'standard',
+                        auto_transition: config.classic?.auto_transition ?? true,
+                    };
+                    await assertClassicLayoutInitializationSafe(projectPath, workflowDecision.classicArtifactLayout, classicLayoutInitializationPermit);
+                }
+                await writeWorkflowProjectConfig(projectPath, config, {
+                    expectedIdentity: initialProjectConfigSnapshot?.identity,
+                });
+                if (classicLayoutInitializationPermit) {
+                    await completeClassicLayoutInitialization(projectPath, classicLayoutInitializationPermit);
+                }
+                projectConfigCreated = initialProjectConfigDocument === null;
+                projectConfigUpdated = initialProjectConfigDocument !== null;
+            }
+        }
+        else if (scope === 'global') {
+            await mergeProjectConfig(baseDir, language.artifactLanguage);
+        }
+    }
+    catch (error) {
+        finalizationFailure = error.message;
+        const target = results[0];
+        if (target) {
+            target.comet = 'failed';
+            target.failures.push({
+                platform: target.platform.id,
+                platformName: target.platform.name,
+                component: 'Finalization',
+                reason: finalizationFailure,
+            });
+        }
+        log(`  Comet finalization failed: ${finalizationFailure}`);
     }
+    const failures = results.flatMap((result) => result.failures);
+    const completionStatus = failures.length > 0 || finalizationFailure ? 'incomplete' : 'complete';
     if (options.json) {
         console.log(JSON.stringify({
+            status: completionStatus,
+            failures,
             projectPath,
             scope,
             language: language.id,
+            workflow,
+            initializedWorkflows: workflowSelection === 'both' ? ['native', 'classic'] : [workflowSelection],
+            workflowSource,
+            projectConfigCreated,
+            projectConfigUpdated,
+            nativeArtifactRoot,
+            classicArtifactLayout: workflowDecision?.classicArtifactLayout ?? null,
             selectedPlatforms: selectedPlatformIds,
+            codegraph,
             results: results.map((result) => ({
                 platform: result.platform.id,
                 platformName: result.platform.name,
@@ -392,11 +880,12 @@ export async function initCommand(targetPath, options = {}) {
                 comet: result.comet,
                 codegraph: result.codegraph,
             })),
-            workingDirsCreated: scope === 'project',
+            workingDirsCreated,
         }, null, 2));
-        return;
+        return { status: completionStatus };
     }
-    displaySummary(results, scope, lang);
+    displaySummary(results, scope, lang, workflowSelection, nativeArtifactRoot, workflowDecision?.classicArtifactLayout ?? null);
+    return { status: completionStatus };
 }
-export { applyBulkOverwriteChoice };
+export { applyBulkOverwriteChoice, workflowChoiceNames };
 //# sourceMappingURL=init.js.map