@fission-ai/openspec 1.14.0 → 1.14.2

package/dist/commands/schema.js

@@ -384,829 +384,789 @@ const DEFAULT_ARTIFACTS = [
         template: 'tasks.md',
     },
 ];
-/**
- * Register the schema command and all its subcommands.
- */
-export function registerSchemaCommand(program) {
-    const schemaCmd = program
-        .command('schema')
-        .description('Manage workflow schemas [experimental]');
-    // Experimental warning
-    schemaCmd.hook('preAction', () => {
-        console.error('Note: Schema commands are experimental and may change.');
-    });
-    // schema which
-    schemaCmd
-        .command('which [name]')
-        .description('Show where a schema resolves from')
-        .option('--json', 'Output as JSON')
-        .option('--all', 'List all schemas with their resolution sources')
-        .action(async (name, options) => {
-        try {
-            const projectRoot = process.cwd();
-            if (options?.all) {
-                // List all schemas
-                const schemas = getAllSchemasWithResolution(projectRoot);
-                if (options?.json) {
-                    console.log(JSON.stringify(schemas, null, 2));
+export async function schemaWhichCommand(name, options) {
+    try {
+        const projectRoot = process.cwd();
+        if (options?.all) {
+            // List all schemas
+            const schemas = getAllSchemasWithResolution(projectRoot);
+            if (options?.json) {
+                console.log(JSON.stringify(schemas, null, 2));
+            }
+            else {
+                if (schemas.length === 0) {
+                    console.log('No schemas found.');
+                    return;
                 }
-                else {
-                    if (schemas.length === 0) {
-                        console.log('No schemas found.');
-                        return;
-                    }
-                    // Group by source
-                    const bySource = {
-                        project: schemas.filter((s) => s.source === 'project'),
-                        user: schemas.filter((s) => s.source === 'user'),
-                        package: schemas.filter((s) => s.source === 'package'),
-                    };
-                    if (bySource.project.length > 0) {
-                        console.log('\nProject schemas:');
-                        for (const schema of bySource.project) {
-                            const shadowInfo = schema.shadows.length > 0
-                                ? ` (shadows: ${schema.shadows.map((s) => s.source).join(', ')})`
-                                : '';
-                            console.log(`  ${schema.name}${shadowInfo}`);
-                        }
-                    }
-                    if (bySource.user.length > 0) {
-                        console.log('\nUser schemas:');
-                        for (const schema of bySource.user) {
-                            const shadowInfo = schema.shadows.length > 0
-                                ? ` (shadows: ${schema.shadows.map((s) => s.source).join(', ')})`
-                                : '';
-                            console.log(`  ${schema.name}${shadowInfo}`);
-                        }
-                    }
-                    if (bySource.package.length > 0) {
-                        console.log('\nPackage schemas:');
-                        for (const schema of bySource.package) {
-                            console.log(`  ${schema.name}`);
-                        }
+                // Group by source
+                const bySource = {
+                    project: schemas.filter((s) => s.source === 'project'),
+                    user: schemas.filter((s) => s.source === 'user'),
+                    package: schemas.filter((s) => s.source === 'package'),
+                };
+                if (bySource.project.length > 0) {
+                    console.log('\nProject schemas:');
+                    for (const schema of bySource.project) {
+                        const shadowInfo = schema.shadows.length > 0
+                            ? ` (shadows: ${schema.shadows.map((s) => s.source).join(', ')})`
+                            : '';
+                        console.log(`  ${schema.name}${shadowInfo}`);
                     }
                 }
-                return;
-            }
-            if (!name) {
-                console.error('Error: Schema name is required (or use --all to list all schemas)');
-                process.exitCode = 1;
-                return;
-            }
-            const resolution = getSchemaResolution(name, projectRoot);
-            if (!resolution) {
-                const available = listSchemas(projectRoot);
-                if (options?.json) {
-                    console.log(JSON.stringify({
-                        error: `Schema '${name}' not found`,
-                        available,
-                    }, null, 2));
+                if (bySource.user.length > 0) {
+                    console.log('\nUser schemas:');
+                    for (const schema of bySource.user) {
+                        const shadowInfo = schema.shadows.length > 0
+                            ? ` (shadows: ${schema.shadows.map((s) => s.source).join(', ')})`
+                            : '';
+                        console.log(`  ${schema.name}${shadowInfo}`);
+                    }
                 }
-                else {
-                    console.error(`Error: Schema '${name}' not found`);
-                    console.error(`Available schemas: ${available.join(', ')}`);
+                if (bySource.package.length > 0) {
+                    console.log('\nPackage schemas:');
+                    for (const schema of bySource.package) {
+                        console.log(`  ${schema.name}`);
+                    }
                 }
-                process.exitCode = 1;
-                return;
             }
+            return;
+        }
+        if (!name) {
+            console.error('Error: Schema name is required (or use --all to list all schemas)');
+            process.exitCode = 1;
+            return;
+        }
+        const resolution = getSchemaResolution(name, projectRoot);
+        if (!resolution) {
+            const available = listSchemas(projectRoot);
             if (options?.json) {
-                console.log(JSON.stringify(resolution, null, 2));
+                console.log(JSON.stringify({
+                    error: `Schema '${name}' not found`,
+                    available,
+                }, null, 2));
             }
             else {
-                console.log(`Schema: ${resolution.name}`);
-                console.log(`Source: ${resolution.source}`);
-                console.log(`Path: ${resolution.path}`);
-                if (resolution.shadows.length > 0) {
-                    console.log('\nShadows:');
-                    for (const shadow of resolution.shadows) {
-                        console.log(`  ${shadow.source}: ${shadow.path}`);
-                    }
-                }
+                console.error(`Error: Schema '${name}' not found`);
+                console.error(`Available schemas: ${available.join(', ')}`);
             }
-        }
-        catch (error) {
-            console.error(`Error: ${error.message}`);
             process.exitCode = 1;
+            return;
         }
-    });
-    // schema validate
-    schemaCmd
-        .command('validate [name]')
-        .description('Validate a schema structure and templates')
-        .option('--json', 'Output as JSON')
-        .option('--verbose', 'Show detailed validation steps')
-        .action(async (name, options) => {
-        try {
-            const projectRoot = process.cwd();
-            if (!name) {
-                // Validate all project schemas
-                const projectSchemasDir = getProjectSchemasDir(projectRoot);
-                if (!fs.existsSync(projectSchemasDir)) {
-                    if (options?.json) {
-                        console.log(JSON.stringify({
-                            valid: true,
-                            message: 'No project schemas directory found',
-                            schemas: [],
-                        }, null, 2));
-                    }
-                    else {
-                        console.log('No project schemas directory found.');
-                    }
-                    return;
-                }
-                const entries = fs.readdirSync(projectSchemasDir, { withFileTypes: true });
-                const schemaResults = [];
-                let anyInvalid = false;
-                for (const entry of entries) {
-                    if (!isSchemaDir(projectSchemasDir, entry))
-                        continue;
-                    const schemaDir = path.join(projectSchemasDir, entry.name);
-                    const schemaPath = path.join(schemaDir, 'schema.yaml');
-                    if (!fs.existsSync(schemaPath))
-                        continue;
-                    if (options?.verbose && !options?.json) {
-                        console.log(`\nValidating ${entry.name}...`);
-                    }
-                    const result = validateSchema(schemaDir, options?.verbose && !options?.json);
-                    schemaResults.push({
-                        name: entry.name,
-                        path: schemaDir,
-                        valid: result.valid,
-                        issues: result.issues,
-                    });
-                    if (!result.valid) {
-                        anyInvalid = true;
-                    }
+        if (options?.json) {
+            console.log(JSON.stringify(resolution, null, 2));
+        }
+        else {
+            console.log(`Schema: ${resolution.name}`);
+            console.log(`Source: ${resolution.source}`);
+            console.log(`Path: ${resolution.path}`);
+            if (resolution.shadows.length > 0) {
+                console.log('\nShadows:');
+                for (const shadow of resolution.shadows) {
+                    console.log(`  ${shadow.source}: ${shadow.path}`);
                 }
+            }
+        }
+    }
+    catch (error) {
+        console.error(`Error: ${error.message}`);
+        process.exitCode = 1;
+    }
+}
+export async function schemaValidateCommand(name, options) {
+    try {
+        const projectRoot = process.cwd();
+        if (!name) {
+            // Validate all project schemas
+            const projectSchemasDir = getProjectSchemasDir(projectRoot);
+            if (!fs.existsSync(projectSchemasDir)) {
                 if (options?.json) {
                     console.log(JSON.stringify({
-                        valid: !anyInvalid,
-                        schemas: schemaResults,
+                        valid: true,
+                        message: 'No project schemas directory found',
+                        schemas: [],
                     }, null, 2));
                 }
                 else {
-                    if (schemaResults.length === 0) {
-                        console.log('No schemas found in project.');
-                        return;
-                    }
-                    console.log('\nValidation Results:');
-                    for (const result of schemaResults) {
-                        const status = result.valid ? '✓' : '✗';
-                        console.log(`  ${status} ${result.name}`);
-                        for (const issue of result.issues) {
-                            console.log(`    ${issue.level}: ${issue.message}`);
-                        }
-                    }
-                }
-                if (anyInvalid) {
-                    process.exitCode = 1;
+                    console.log('No project schemas directory found.');
                 }
                 return;
             }
-            // Validate specific schema
-            const schemaDir = getSchemaDir(name, projectRoot);
-            if (!schemaDir) {
-                const available = listSchemas(projectRoot);
-                if (options?.json) {
-                    console.log(JSON.stringify({
-                        valid: false,
-                        error: `Schema '${name}' not found`,
-                        available,
-                    }, null, 2));
+            const entries = fs.readdirSync(projectSchemasDir, { withFileTypes: true });
+            const schemaResults = [];
+            let anyInvalid = false;
+            for (const entry of entries) {
+                if (!isSchemaDir(projectSchemasDir, entry))
+                    continue;
+                const schemaDir = path.join(projectSchemasDir, entry.name);
+                const schemaPath = path.join(schemaDir, 'schema.yaml');
+                if (!fs.existsSync(schemaPath))
+                    continue;
+                if (options?.verbose && !options?.json) {
+                    console.log(`\nValidating ${entry.name}...`);
                 }
-                else {
-                    console.error(`Error: Schema '${name}' not found`);
-                    console.error(`Available schemas: ${available.join(', ')}`);
+                const result = validateSchema(schemaDir, options?.verbose && !options?.json);
+                schemaResults.push({
+                    name: entry.name,
+                    path: schemaDir,
+                    valid: result.valid,
+                    issues: result.issues,
+                });
+                if (!result.valid) {
+                    anyInvalid = true;
                 }
-                process.exitCode = 1;
-                return;
             }
-            if (options?.verbose && !options?.json) {
-                console.log(`Validating ${name}...`);
-            }
-            const result = validateSchema(schemaDir, options?.verbose && !options?.json);
             if (options?.json) {
                 console.log(JSON.stringify({
-                    name,
-                    path: schemaDir,
-                    valid: result.valid,
-                    issues: result.issues,
+                    valid: !anyInvalid,
+                    schemas: schemaResults,
                 }, null, 2));
             }
             else {
-                if (result.valid) {
-                    console.log(`✓ Schema '${name}' is valid`);
-                    for (const issue of result.issues) {
-                        console.log(`  ${issue.level}: ${issue.message}`);
-                    }
+                if (schemaResults.length === 0) {
+                    console.log('No schemas found in project.');
+                    return;
                 }
-                else {
-                    console.log(`✗ Schema '${name}' has errors:`);
+                console.log('\nValidation Results:');
+                for (const result of schemaResults) {
+                    const status = result.valid ? '✓' : '✗';
+                    console.log(`  ${status} ${result.name}`);
                     for (const issue of result.issues) {
-                        console.log(`  ${issue.level}: ${issue.message}`);
+                        console.log(`    ${issue.level}: ${issue.message}`);
                     }
                 }
             }
-            if (!result.valid) {
+            if (anyInvalid) {
                 process.exitCode = 1;
             }
+            return;
         }
-        catch (error) {
+        // Validate specific schema
+        const schemaDir = getSchemaDir(name, projectRoot);
+        if (!schemaDir) {
+            const available = listSchemas(projectRoot);
             if (options?.json) {
                 console.log(JSON.stringify({
                     valid: false,
-                    error: error.message,
+                    error: `Schema '${name}' not found`,
+                    available,
                 }, null, 2));
             }
             else {
-                console.error(`Error: ${error.message}`);
+                console.error(`Error: Schema '${name}' not found`);
+                console.error(`Available schemas: ${available.join(', ')}`);
             }
             process.exitCode = 1;
+            return;
         }
-    });
-    // schema fork
-    schemaCmd
-        .command('fork <source> [name]')
-        .description('Copy an existing schema to project for customization')
-        .option('--json', 'Output as JSON')
-        .option('--force', 'Overwrite existing destination')
-        .action(async (source, name, options) => {
-        const spinner = options?.json ? null : ora();
-        try {
-            const projectRoot = process.cwd();
-            const destinationName = name || `${source}-custom`;
-            // Validate destination name
-            if (!isValidSchemaName(destinationName)) {
-                if (options?.json) {
-                    console.log(JSON.stringify({
-                        forked: false,
-                        error: `Invalid schema name '${destinationName}'. Use kebab-case (e.g., my-workflow)`,
-                    }, null, 2));
-                }
-                else {
-                    console.error(`Error: Invalid schema name '${destinationName}'`);
-                    console.error('Schema names must be kebab-case (e.g., my-workflow)');
+        if (options?.verbose && !options?.json) {
+            console.log(`Validating ${name}...`);
+        }
+        const result = validateSchema(schemaDir, options?.verbose && !options?.json);
+        if (options?.json) {
+            console.log(JSON.stringify({
+                name,
+                path: schemaDir,
+                valid: result.valid,
+                issues: result.issues,
+            }, null, 2));
+        }
+        else {
+            if (result.valid) {
+                console.log(`✓ Schema '${name}' is valid`);
+                for (const issue of result.issues) {
+                    console.log(`  ${issue.level}: ${issue.message}`);
                 }
-                process.exitCode = 1;
-                return;
             }
-            // Find source schema
-            const sourceDir = getSchemaDir(source, projectRoot);
-            if (!sourceDir) {
-                const available = listSchemas(projectRoot);
-                if (options?.json) {
-                    console.log(JSON.stringify({
-                        forked: false,
-                        error: `Schema '${source}' not found`,
-                        available,
-                    }, null, 2));
-                }
-                else {
-                    console.error(`Error: Schema '${source}' not found`);
-                    console.error(`Available schemas: ${available.join(', ')}`);
+            else {
+                console.log(`✗ Schema '${name}' has errors:`);
+                for (const issue of result.issues) {
+                    console.log(`  ${issue.level}: ${issue.message}`);
                 }
-                process.exitCode = 1;
-                return;
             }
-            // Determine source location
-            const sourceResolution = getSchemaResolution(source, projectRoot);
-            const sourceLocation = sourceResolution?.source || 'package';
-            // Validate the complete source before a forced fork removes anything.
-            const trustedSourceDir = fs.realpathSync(sourceDir);
-            assertSchemaTreeCanBeCopied(trustedSourceDir);
-            // Validate the source's schema content up front too, so a structurally
-            // invalid source is rejected before the --force path can remove an
-            // existing destination. This keeps `fork --force` atomic — an unusable
-            // source never destroys a valid destination — matching `schema init`,
-            // which likewise validates before it overwrites.
-            parseSchema(fs.readFileSync(path.join(trustedSourceDir, 'schema.yaml'), 'utf-8'));
-            // Check destination
-            const schemasDir = getProjectSchemasDir(projectRoot);
-            const destinationDir = path.join(schemasDir, destinationName);
-            // Reject a self-fork. Forking a schema onto itself with --force would
-            // otherwise remove the source at the replacement step below and then
-            // fail the copy, destroying the only copy of the schema. Resolve both
-            // sides to their real paths (realpathSync follows symlinks; path.resolve
-            // is a fallback only for a destination that does not exist yet) so a
-            // symlink or a `.`/`..` spelling of the same directory is still caught.
-            const resolvedDestination = fs.existsSync(destinationDir)
-                ? fs.realpathSync(destinationDir)
-                : path.resolve(destinationDir);
-            if (resolvedDestination === trustedSourceDir) {
-                throw new Error(`Cannot fork schema '${source}' onto itself; choose a different destination name`);
+        }
+        if (!result.valid) {
+            process.exitCode = 1;
+        }
+    }
+    catch (error) {
+        if (options?.json) {
+            console.log(JSON.stringify({
+                valid: false,
+                error: error.message,
+            }, null, 2));
+        }
+        else {
+            console.error(`Error: ${error.message}`);
+        }
+        process.exitCode = 1;
+    }
+}
+export async function schemaForkCommand(source, name, options) {
+    const spinner = options?.json ? null : ora();
+    try {
+        const projectRoot = process.cwd();
+        const destinationName = name || `${source}-custom`;
+        // Validate destination name
+        if (!isValidSchemaName(destinationName)) {
+            if (options?.json) {
+                console.log(JSON.stringify({
+                    forked: false,
+                    error: `Invalid schema name '${destinationName}'. Use kebab-case (e.g., my-workflow)`,
+                }, null, 2));
+            }
+            else {
+                console.error(`Error: Invalid schema name '${destinationName}'`);
+                console.error('Schema names must be kebab-case (e.g., my-workflow)');
             }
-            const destinationExists = fs.existsSync(destinationDir);
-            if (destinationExists && !options?.force) {
-                if (options?.json) {
-                    console.log(JSON.stringify({
-                        forked: false,
-                        error: `Schema '${destinationName}' already exists`,
-                        suggestion: 'Use --force to overwrite',
-                    }, null, 2));
-                }
-                else {
-                    console.error(`Error: Schema '${destinationName}' already exists at ${destinationDir}`);
-                    console.error('Use --force to overwrite');
-                }
-                process.exitCode = 1;
-                return;
+            process.exitCode = 1;
+            return;
+        }
+        // Find source schema
+        const sourceDir = getSchemaDir(source, projectRoot);
+        if (!sourceDir) {
+            const available = listSchemas(projectRoot);
+            if (options?.json) {
+                console.log(JSON.stringify({
+                    forked: false,
+                    error: `Schema '${source}' not found`,
+                    available,
+                }, null, 2));
             }
-            // Fingerprint the destination the user authorized us to overwrite, BEFORE
-            // we spend time staging. Staging can take a while, and a concurrent
-            // process may edit the destination in that window; the fingerprint lets
-            // us detect such a change and abort rather than clobber it.
-            const authorizedDestinationFingerprint = destinationExists
-                ? fingerprintDir(destinationDir)
-                : null;
-            // Stage the complete fork in a temporary sibling directory first, then
-            // swap it into place. This keeps `fork --force` atomic: an existing
-            // destination is only removed once the new fork has been fully copied,
-            // name-updated, and (via the up-front parseSchema above) validated. Any
-            // failure while staging leaves both the source and the existing
-            // destination exactly as they were.
-            if (spinner)
-                spinner.start(`Forking '${source}' to '${destinationName}'...`);
-            fs.mkdirSync(schemasDir, { recursive: true });
-            const stagingDir = fs.mkdtempSync(path.join(schemasDir, '.fork-staging-'));
+            else {
+                console.error(`Error: Schema '${source}' not found`);
+                console.error(`Available schemas: ${available.join(', ')}`);
+            }
+            process.exitCode = 1;
+            return;
+        }
+        // Determine source location
+        const sourceResolution = getSchemaResolution(source, projectRoot);
+        const sourceLocation = sourceResolution?.source || 'package';
+        // Validate the complete source before a forced fork removes anything.
+        const trustedSourceDir = fs.realpathSync(sourceDir);
+        assertSchemaTreeCanBeCopied(trustedSourceDir);
+        // Validate the source's schema content up front too, so a structurally
+        // invalid source is rejected before the --force path can remove an
+        // existing destination. This keeps `fork --force` atomic — an unusable
+        // source never destroys a valid destination — matching `schema init`,
+        // which likewise validates before it overwrites.
+        parseSchema(fs.readFileSync(path.join(trustedSourceDir, 'schema.yaml'), 'utf-8'));
+        // Check destination
+        const schemasDir = getProjectSchemasDir(projectRoot);
+        const destinationDir = path.join(schemasDir, destinationName);
+        // Reject a self-fork. Forking a schema onto itself with --force would
+        // otherwise remove the source at the replacement step below and then
+        // fail the copy, destroying the only copy of the schema. Resolve both
+        // sides to their real paths (realpathSync follows symlinks; path.resolve
+        // is a fallback only for a destination that does not exist yet) so a
+        // symlink or a `.`/`..` spelling of the same directory is still caught.
+        const resolvedDestination = fs.existsSync(destinationDir)
+            ? fs.realpathSync(destinationDir)
+            : path.resolve(destinationDir);
+        if (resolvedDestination === trustedSourceDir) {
+            throw new Error(`Cannot fork schema '${source}' onto itself; choose a different destination name`);
+        }
+        const destinationExists = fs.existsSync(destinationDir);
+        if (destinationExists && !options?.force) {
+            if (options?.json) {
+                console.log(JSON.stringify({
+                    forked: false,
+                    error: `Schema '${destinationName}' already exists`,
+                    suggestion: 'Use --force to overwrite',
+                }, null, 2));
+            }
+            else {
+                console.error(`Error: Schema '${destinationName}' already exists at ${destinationDir}`);
+                console.error('Use --force to overwrite');
+            }
+            process.exitCode = 1;
+            return;
+        }
+        // Fingerprint the destination the user authorized us to overwrite, BEFORE
+        // we spend time staging. Staging can take a while, and a concurrent
+        // process may edit the destination in that window; the fingerprint lets
+        // us detect such a change and abort rather than clobber it.
+        const authorizedDestinationFingerprint = destinationExists
+            ? fingerprintDir(destinationDir)
+            : null;
+        // Stage the complete fork in a temporary sibling directory first, then
+        // swap it into place. This keeps `fork --force` atomic: an existing
+        // destination is only removed once the new fork has been fully copied,
+        // name-updated, and (via the up-front parseSchema above) validated. Any
+        // failure while staging leaves both the source and the existing
+        // destination exactly as they were.
+        if (spinner)
+            spinner.start(`Forking '${source}' to '${destinationName}'...`);
+        fs.mkdirSync(schemasDir, { recursive: true });
+        const stagingDir = fs.mkdtempSync(path.join(schemasDir, '.fork-staging-'));
+        try {
+            copyDirRecursive(trustedSourceDir, stagingDir);
+            // Update name in the staged schema.yaml via yaml's Document API
+            // instead of re-serializing the parsed object, so block scalars,
+            // comments, and key order in the source schema.yaml survive the fork.
+            const stagedSchemaPath = path.join(stagingDir, 'schema.yaml');
+            const schemaContent = fs.readFileSync(stagedSchemaPath, 'utf-8');
+            const doc = parseDocument(schemaContent);
+            doc.set('name', destinationName);
+            fs.writeFileSync(stagedSchemaPath, doc.toString());
+            // Authoritative gate: validate the COMPLETED staged schema — the exact
+            // bytes we are about to install — not just the source at the pre-check.
+            // The source files copyDirRecursive reads can change mid-copy, so a
+            // source that was valid up front can still produce an invalid staged
+            // fork. Validating here, before ANY destructive step, guarantees we
+            // never install an invalid fork or delete a valid destination for one.
             try {
-                copyDirRecursive(trustedSourceDir, stagingDir);
-                // Update name in the staged schema.yaml via yaml's Document API
-                // instead of re-serializing the parsed object, so block scalars,
-                // comments, and key order in the source schema.yaml survive the fork.
-                const stagedSchemaPath = path.join(stagingDir, 'schema.yaml');
-                const schemaContent = fs.readFileSync(stagedSchemaPath, 'utf-8');
-                const doc = parseDocument(schemaContent);
-                doc.set('name', destinationName);
-                fs.writeFileSync(stagedSchemaPath, doc.toString());
-                // Authoritative gate: validate the COMPLETED staged schema — the exact
-                // bytes we are about to install — not just the source at the pre-check.
-                // The source files copyDirRecursive reads can change mid-copy, so a
-                // source that was valid up front can still produce an invalid staged
-                // fork. Validating here, before ANY destructive step, guarantees we
-                // never install an invalid fork or delete a valid destination for one.
-                try {
-                    parseSchema(fs.readFileSync(stagedSchemaPath, 'utf-8'));
+                parseSchema(fs.readFileSync(stagedSchemaPath, 'utf-8'));
+            }
+            catch (validationError) {
+                throw new Error(`The staged fork of '${source}' is not a valid schema (the source may have changed during copy); ` +
+                    `aborted, '${destinationName}' was not modified.`, { cause: validationError });
+            }
+            // Swap the staged fork into place. When a destination already exists,
+            // move it aside to a sibling backup FIRST, then install the staged
+            // fork; only once the install succeeds is the backup discarded. If the
+            // install rename itself fails (e.g. a Windows lock), the backup is
+            // moved back so the user's original destination is never lost.
+            if (destinationExists) {
+                if (spinner)
+                    spinner.text = `Replacing existing schema '${destinationName}'...`;
+                // Revalidate immediately before the destructive move: if the
+                // destination changed on disk while we were staging (or was removed),
+                // its fingerprint no longer matches what the user authorized. Abort
+                // WITHOUT touching it, so the concurrent changes are preserved. The
+                // outer catch cleans up staging.
+                const currentFingerprint = fs.existsSync(destinationDir)
+                    ? fingerprintDir(destinationDir)
+                    : null;
+                if (currentFingerprint !== authorizedDestinationFingerprint) {
+                    throw new Error(`Schema '${destinationName}' at ${destinationDir} changed on disk while the fork was being prepared. ` +
+                        `Aborted to preserve those concurrent changes; nothing was overwritten. Re-run the fork to overwrite the current contents.`);
                 }
-                catch (validationError) {
-                    throw new Error(`The staged fork of '${source}' is not a valid schema (the source may have changed during copy); ` +
-                        `aborted, '${destinationName}' was not modified.`, { cause: validationError });
+                const backupDir = `${destinationDir}.fork-backup-${process.pid}-${Date.now()}`;
+                fs.renameSync(destinationDir, backupDir);
+                try {
+                    fs.renameSync(stagingDir, destinationDir);
                 }
-                // Swap the staged fork into place. When a destination already exists,
-                // move it aside to a sibling backup FIRST, then install the staged
-                // fork; only once the install succeeds is the backup discarded. If the
-                // install rename itself fails (e.g. a Windows lock), the backup is
-                // moved back so the user's original destination is never lost.
-                if (destinationExists) {
-                    if (spinner)
-                        spinner.text = `Replacing existing schema '${destinationName}'...`;
-                    // Revalidate immediately before the destructive move: if the
-                    // destination changed on disk while we were staging (or was removed),
-                    // its fingerprint no longer matches what the user authorized. Abort
-                    // WITHOUT touching it, so the concurrent changes are preserved. The
-                    // outer catch cleans up staging.
-                    const currentFingerprint = fs.existsSync(destinationDir)
-                        ? fingerprintDir(destinationDir)
-                        : null;
-                    if (currentFingerprint !== authorizedDestinationFingerprint) {
-                        throw new Error(`Schema '${destinationName}' at ${destinationDir} changed on disk while the fork was being prepared. ` +
-                            `Aborted to preserve those concurrent changes; nothing was overwritten. Re-run the fork to overwrite the current contents.`);
-                    }
-                    const backupDir = `${destinationDir}.fork-backup-${process.pid}-${Date.now()}`;
-                    fs.renameSync(destinationDir, backupDir);
+                catch (installError) {
+                    // Install failed after the original was moved aside. Try to move
+                    // it back. If that restore ALSO fails, the original is stranded in
+                    // the backup dir — surface an error naming both the backup and the
+                    // destination so the user can recover manually, and attach the
+                    // original install error as the cause. Never swallow this.
                     try {
-                        fs.renameSync(stagingDir, destinationDir);
+                        fs.renameSync(backupDir, destinationDir);
                     }
-                    catch (installError) {
-                        // Install failed after the original was moved aside. Try to move
-                        // it back. If that restore ALSO fails, the original is stranded in
-                        // the backup dir — surface an error naming both the backup and the
-                        // destination so the user can recover manually, and attach the
-                        // original install error as the cause. Never swallow this.
-                        try {
-                            fs.renameSync(backupDir, destinationDir);
-                        }
-                        catch (restoreError) {
-                            throw new Error(`Failed to install the forked schema and could not restore the previous '${destinationName}'. ` +
-                                `Your previous schema is preserved at ${backupDir}; move it back to ${destinationDir} to restore. ` +
-                                `Restore error: ${restoreError.message}`, { cause: installError });
-                        }
-                        throw installError;
+                    catch (restoreError) {
+                        throw new Error(`Failed to install the forked schema and could not restore the previous '${destinationName}'. ` +
+                            `Your previous schema is preserved at ${backupDir}; move it back to ${destinationDir} to restore. ` +
+                            `Restore error: ${restoreError.message}`, { cause: installError });
                     }
-                    // Revalidate before discarding the backup: only delete it if it is
-                    // still byte-for-byte the original destination we moved aside. If it
-                    // changed during the install window (a concurrent write to the
-                    // moved-aside directory), do NOT delete it — leave it in place and
-                    // surface where it is so nothing is lost.
-                    if (fingerprintDir(backupDir) === authorizedDestinationFingerprint) {
-                        fs.rmSync(backupDir, { recursive: true, force: true });
-                    }
-                    else {
-                        console.error(`Warning: the previous '${destinationName}' changed during the fork and was NOT deleted; ` +
-                            `its pre-fork copy is preserved at ${backupDir}.`);
-                    }
-                }
-                else {
-                    fs.renameSync(stagingDir, destinationDir);
+                    throw installError;
                 }
-            }
-            catch (error) {
-                // Remove only the staging directory we created this run; the source
-                // and any existing destination are left exactly as we found them.
-                // Guard the cleanup in its own try/catch so a failed removal (e.g. a
-                // locked file on Windows) can never mask the original error, then
-                // rethrow so the real failure still drives the JSON/exit-code report.
-                try {
-                    fs.rmSync(stagingDir, { recursive: true, force: true });
+                // Revalidate before discarding the backup: only delete it if it is
+                // still byte-for-byte the original destination we moved aside. If it
+                // changed during the install window (a concurrent write to the
+                // moved-aside directory), do NOT delete it — leave it in place and
+                // surface where it is so nothing is lost.
+                if (fingerprintDir(backupDir) === authorizedDestinationFingerprint) {
+                    fs.rmSync(backupDir, { recursive: true, force: true });
                 }
-                catch {
-                    // Best-effort cleanup; the original error below is what matters.
+                else {
+                    console.error(`Warning: the previous '${destinationName}' changed during the fork and was NOT deleted; ` +
+                        `its pre-fork copy is preserved at ${backupDir}.`);
                 }
-                throw error;
-            }
-            if (spinner)
-                spinner.succeed(`Forked '${source}' to '${destinationName}'`);
-            if (options?.json) {
-                console.log(JSON.stringify({
-                    forked: true,
-                    source,
-                    sourcePath: sourceDir,
-                    sourceLocation,
-                    destination: destinationName,
-                    destinationPath: destinationDir,
-                }, null, 2));
             }
             else {
-                console.log(`\nSource: ${sourceDir} (${sourceLocation})`);
-                console.log(`Destination: ${destinationDir}`);
-                console.log(`\nYou can now customize the schema at:`);
-                console.log(`  ${destinationDir}/schema.yaml`);
+                fs.renameSync(stagingDir, destinationDir);
             }
         }
         catch (error) {
-            if (spinner)
-                spinner.fail(`Fork failed`);
+            // Remove only the staging directory we created this run; the source
+            // and any existing destination are left exactly as we found them.
+            // Guard the cleanup in its own try/catch so a failed removal (e.g. a
+            // locked file on Windows) can never mask the original error, then
+            // rethrow so the real failure still drives the JSON/exit-code report.
+            try {
+                fs.rmSync(stagingDir, { recursive: true, force: true });
+            }
+            catch {
+                // Best-effort cleanup; the original error below is what matters.
+            }
+            throw error;
+        }
+        if (spinner)
+            spinner.succeed(`Forked '${source}' to '${destinationName}'`);
+        if (options?.json) {
+            console.log(JSON.stringify({
+                forked: true,
+                source,
+                sourcePath: sourceDir,
+                sourceLocation,
+                destination: destinationName,
+                destinationPath: destinationDir,
+            }, null, 2));
+        }
+        else {
+            console.log(`\nSource: ${sourceDir} (${sourceLocation})`);
+            console.log(`Destination: ${destinationDir}`);
+            console.log(`\nYou can now customize the schema at:`);
+            console.log(`  ${destinationDir}/schema.yaml`);
+        }
+    }
+    catch (error) {
+        if (spinner)
+            spinner.fail(`Fork failed`);
+        if (options?.json) {
+            console.log(JSON.stringify({
+                forked: false,
+                error: error.message,
+            }, null, 2));
+        }
+        else {
+            console.error(`Error: ${error.message}`);
+        }
+        process.exitCode = 1;
+    }
+}
+export async function schemaInitCommand(name, options) {
+    const spinner = options?.json ? null : ora();
+    try {
+        const projectRoot = process.cwd();
+        // Validate name
+        if (!isValidSchemaName(name)) {
             if (options?.json) {
                 console.log(JSON.stringify({
-                    forked: false,
-                    error: error.message,
+                    created: false,
+                    error: `Invalid schema name '${name}'. Use kebab-case (e.g., my-workflow)`,
                 }, null, 2));
             }
             else {
-                console.error(`Error: ${error.message}`);
+                console.error(`Error: Invalid schema name '${name}'`);
+                console.error('Schema names must be kebab-case (e.g., my-workflow)');
             }
             process.exitCode = 1;
+            return;
         }
-    });
-    // schema init
-    schemaCmd
-        .command('init <name>')
-        .description('Create a new project-local schema')
-        .option('--json', 'Output as JSON')
-        .option('--description <text>', 'Schema description')
-        .option('--artifacts <list>', 'Comma-separated artifact IDs (proposal,specs,design,tasks)')
-        .option('--default', 'Set as project default schema')
-        .option('--no-default', 'Do not prompt to set as default')
-        .option('--force', 'Overwrite existing schema')
-        .action(async (name, options) => {
-        const spinner = options?.json ? null : ora();
-        try {
-            const projectRoot = process.cwd();
-            // Validate name
-            if (!isValidSchemaName(name)) {
+        const schemaDir = path.join(getProjectSchemasDir(projectRoot), name);
+        // Check overwrite permission without mutating the destination
+        const schemaExists = fs.existsSync(schemaDir);
+        if (schemaExists) {
+            if (!options?.force) {
                 if (options?.json) {
                     console.log(JSON.stringify({
                         created: false,
-                        error: `Invalid schema name '${name}'. Use kebab-case (e.g., my-workflow)`,
+                        error: `Schema '${name}' already exists`,
+                        suggestion: 'Use --force to overwrite or "openspec schema fork" to copy',
                     }, null, 2));
                 }
                 else {
-                    console.error(`Error: Invalid schema name '${name}'`);
-                    console.error('Schema names must be kebab-case (e.g., my-workflow)');
+                    console.error(`Error: Schema '${name}' already exists at ${schemaDir}`);
+                    console.error('Use --force to overwrite or "openspec schema fork" to copy');
                 }
                 process.exitCode = 1;
                 return;
             }
-            const schemaDir = path.join(getProjectSchemasDir(projectRoot), name);
-            // Check overwrite permission without mutating the destination
-            const schemaExists = fs.existsSync(schemaDir);
-            if (schemaExists) {
-                if (!options?.force) {
-                    if (options?.json) {
-                        console.log(JSON.stringify({
-                            created: false,
-                            error: `Schema '${name}' already exists`,
-                            suggestion: 'Use --force to overwrite or "openspec schema fork" to copy',
-                        }, null, 2));
-                    }
-                    else {
-                        console.error(`Error: Schema '${name}' already exists at ${schemaDir}`);
-                        console.error('Use --force to overwrite or "openspec schema fork" to copy');
-                    }
-                    process.exitCode = 1;
-                    return;
-                }
-            }
-            // Determine artifacts and description
-            let description;
-            let selectedArtifactIds;
-            // Check if we have explicit flags (non-interactive mode)
-            const hasExplicitOptions = options?.description !== undefined || options?.artifacts !== undefined;
-            const isInteractive = !options?.json && !hasExplicitOptions && process.stdout.isTTY;
-            if (isInteractive) {
-                // Interactive mode
-                const { input, checkbox, confirm } = await import('@inquirer/prompts');
-                description = await input({
-                    message: 'Schema description:',
-                    default: `Custom workflow schema for ${name}`,
-                });
-                const artifactChoices = DEFAULT_ARTIFACTS.map((a) => ({
-                    name: a.id,
-                    value: a.id,
-                    checked: true,
-                }));
-                selectedArtifactIds = await checkbox({
-                    message: 'Select artifacts to include:',
-                    theme: {
-                        icon: {
-                            checked: '[x]',
-                            unchecked: '[ ]',
-                        },
+        }
+        // Determine artifacts and description
+        let description;
+        let selectedArtifactIds;
+        // Check if we have explicit flags (non-interactive mode)
+        const hasExplicitOptions = options?.description !== undefined || options?.artifacts !== undefined;
+        const isInteractive = !options?.json && !hasExplicitOptions && process.stdout.isTTY;
+        if (isInteractive) {
+            // Interactive mode
+            const { input, checkbox, confirm } = await import('@inquirer/prompts');
+            description = await input({
+                message: 'Schema description:',
+                default: `Custom workflow schema for ${name}`,
+            });
+            const artifactChoices = DEFAULT_ARTIFACTS.map((a) => ({
+                name: a.id,
+                value: a.id,
+                checked: true,
+            }));
+            selectedArtifactIds = await checkbox({
+                message: 'Select artifacts to include:',
+                theme: {
+                    icon: {
+                        checked: '[x]',
+                        unchecked: '[ ]',
                     },
-                    choices: artifactChoices,
+                },
+                choices: artifactChoices,
+            });
+            if (selectedArtifactIds.length === 0) {
+                console.error('Error: At least one artifact must be selected');
+                process.exitCode = 1;
+                return;
+            }
+            // Ask about setting as default (unless --no-default was passed)
+            if (options?.default === undefined) {
+                const setAsDefault = await confirm({
+                    message: 'Set as project default schema?',
+                    default: false,
                 });
-                if (selectedArtifactIds.length === 0) {
-                    console.error('Error: At least one artifact must be selected');
-                    process.exitCode = 1;
-                    return;
-                }
-                // Ask about setting as default (unless --no-default was passed)
-                if (options?.default === undefined) {
-                    const setAsDefault = await confirm({
-                        message: 'Set as project default schema?',
-                        default: false,
-                    });
-                    if (setAsDefault) {
-                        options = { ...options, default: true };
-                    }
+                if (setAsDefault) {
+                    options = { ...options, default: true };
                 }
             }
-            else {
-                // Non-interactive mode
-                description = options?.description || `Custom workflow schema for ${name}`;
-                if (options?.artifacts) {
-                    selectedArtifactIds = options.artifacts.split(',').map((a) => a.trim());
-                    // Validate artifact IDs
-                    const validIds = DEFAULT_ARTIFACTS.map((a) => a.id);
-                    for (const id of selectedArtifactIds) {
-                        if (!validIds.includes(id)) {
-                            if (options?.json) {
-                                console.log(JSON.stringify({
-                                    created: false,
-                                    error: `Unknown artifact '${id}'`,
-                                    valid: validIds,
-                                }, null, 2));
-                            }
-                            else {
-                                console.error(`Error: Unknown artifact '${id}'`);
-                                console.error(`Valid artifacts: ${validIds.join(', ')}`);
-                            }
-                            process.exitCode = 1;
-                            return;
+        }
+        else {
+            // Non-interactive mode
+            description = options?.description || `Custom workflow schema for ${name}`;
+            if (options?.artifacts) {
+                selectedArtifactIds = options.artifacts.split(',').map((a) => a.trim());
+                // Validate artifact IDs
+                const validIds = DEFAULT_ARTIFACTS.map((a) => a.id);
+                for (const id of selectedArtifactIds) {
+                    if (!validIds.includes(id)) {
+                        if (options?.json) {
+                            console.log(JSON.stringify({
+                                created: false,
+                                error: `Unknown artifact '${id}'`,
+                                valid: validIds,
+                            }, null, 2));
                         }
+                        else {
+                            console.error(`Error: Unknown artifact '${id}'`);
+                            console.error(`Valid artifacts: ${validIds.join(', ')}`);
+                        }
+                        process.exitCode = 1;
+                        return;
                     }
                 }
-                else {
-                    // Default to all artifacts
-                    selectedArtifactIds = DEFAULT_ARTIFACTS.map((a) => a.id);
-                }
             }
-            // Build artifacts array with proper dependencies
-            const selectedArtifacts = selectedArtifactIds.map((id) => {
-                const template = DEFAULT_ARTIFACTS.find((a) => a.id === id);
-                const artifact = {
-                    id: template.id,
-                    generates: template.generates,
-                    description: template.description,
-                    template: template.template,
-                    requires: [],
-                };
-                // Set up dependencies based on typical workflow
-                if (id === 'specs' && selectedArtifactIds.includes('proposal')) {
-                    artifact.requires = ['proposal'];
-                }
-                else if (id === 'design' && selectedArtifactIds.includes('specs')) {
-                    artifact.requires = ['specs'];
-                }
-                else if (id === 'tasks') {
-                    const requires = [];
-                    if (selectedArtifactIds.includes('design'))
-                        requires.push('design');
-                    else if (selectedArtifactIds.includes('specs'))
-                        requires.push('specs');
-                    artifact.requires = requires;
-                }
-                return artifact;
-            });
-            // Create schema.yaml
-            const schema = {
-                name,
-                version: 1,
-                description,
-                artifacts: selectedArtifacts,
+            else {
+                // Default to all artifacts
+                selectedArtifactIds = DEFAULT_ARTIFACTS.map((a) => a.id);
+            }
+        }
+        // Build artifacts array with proper dependencies
+        const selectedArtifacts = selectedArtifactIds.map((id) => {
+            const template = DEFAULT_ARTIFACTS.find((a) => a.id === id);
+            const artifact = {
+                id: template.id,
+                generates: template.generates,
+                description: template.description,
+                template: template.template,
+                requires: [],
             };
-            // Add apply phase if tasks is included
-            if (selectedArtifactIds.includes('tasks')) {
-                schema.apply = {
-                    requires: ['tasks'],
-                    tracks: 'tasks.md',
-                };
+            // Set up dependencies based on typical workflow
+            if (id === 'specs' && selectedArtifactIds.includes('proposal')) {
+                artifact.requires = ['proposal'];
             }
-            // Parse and serialize the config before staging any schema files. This
-            // makes malformed, non-object, linked, and read-only configs fail before
-            // an existing schema can be moved or a new one can appear.
-            const preparedConfig = options?.default
-                ? await prepareDefaultConfigUpdate(projectRoot, name)
-                : null;
-            const schemasDir = getProjectSchemasDir(projectRoot);
+            else if (id === 'design' && selectedArtifactIds.includes('specs')) {
+                artifact.requires = ['specs'];
+            }
+            else if (id === 'tasks') {
+                const requires = [];
+                if (selectedArtifactIds.includes('design'))
+                    requires.push('design');
+                else if (selectedArtifactIds.includes('specs'))
+                    requires.push('specs');
+                artifact.requires = requires;
+            }
+            return artifact;
+        });
+        // Create schema.yaml
+        const schema = {
+            name,
+            version: 1,
+            description,
+            artifacts: selectedArtifacts,
+        };
+        // Add apply phase if tasks is included
+        if (selectedArtifactIds.includes('tasks')) {
+            schema.apply = {
+                requires: ['tasks'],
+                tracks: 'tasks.md',
+            };
+        }
+        // Parse and serialize the config before staging any schema files. This
+        // makes malformed, non-object, linked, and read-only configs fail before
+        // an existing schema can be moved or a new one can appear.
+        const preparedConfig = options?.default
+            ? await prepareDefaultConfigUpdate(projectRoot, name)
+            : null;
+        const schemasDir = getProjectSchemasDir(projectRoot);
+        FileSystemUtils.assertProjectArtifactPath(projectRoot, schemaDir);
+        const authorizedSchemaFingerprint = schemaExists
+            ? fingerprintDir(schemaDir)
+            : null;
+        if (spinner)
+            spinner.start(`Creating schema '${name}'...`);
+        fs.mkdirSync(schemasDir, { recursive: true });
+        const schemaStagingDir = fs.mkdtempSync(path.join(schemasDir, '.init-staging-'));
+        let configStagingDir = null;
+        let stagedConfigPath = null;
+        try {
+            fs.writeFileSync(path.join(schemaStagingDir, 'schema.yaml'), stringifyYaml(schema));
+            const templatesDir = path.join(schemaStagingDir, 'templates');
+            for (const artifact of selectedArtifacts) {
+                const templatePath = path.join(templatesDir, artifact.template);
+                fs.mkdirSync(path.dirname(templatePath), { recursive: true });
+                fs.writeFileSync(templatePath, createDefaultTemplate(artifact.id));
+            }
+            const validation = validateSchema(schemaStagingDir);
+            if (!validation.valid) {
+                throw new Error(`Generated schema failed validation: ${validation.issues
+                    .map((issue) => issue.message)
+                    .join('; ')}`);
+            }
+            if (preparedConfig) {
+                const configDir = path.dirname(preparedConfig.path);
+                configStagingDir = fs.mkdtempSync(path.join(configDir, '.schema-init-config-'));
+                stagedConfigPath = path.join(configStagingDir, path.basename(preparedConfig.path));
+                fs.writeFileSync(stagedConfigPath, preparedConfig.content);
+                if (preparedConfig.originalMode !== null) {
+                    fs.chmodSync(stagedConfigPath, preparedConfig.originalMode);
+                }
+            }
+            // Re-resolve both destinations immediately before the first move so
+            // a parent symlink swap during staging cannot redirect the commit.
             FileSystemUtils.assertProjectArtifactPath(projectRoot, schemaDir);
-            const authorizedSchemaFingerprint = schemaExists
+            if (preparedConfig) {
+                FileSystemUtils.assertProjectArtifactPath(projectRoot, preparedConfig.path);
+            }
+            const currentSchemaFingerprint = fs.existsSync(schemaDir)
                 ? fingerprintDir(schemaDir)
                 : null;
-            if (spinner)
-                spinner.start(`Creating schema '${name}'...`);
-            fs.mkdirSync(schemasDir, { recursive: true });
-            const schemaStagingDir = fs.mkdtempSync(path.join(schemasDir, '.init-staging-'));
-            let configStagingDir = null;
-            let stagedConfigPath = null;
+            if (currentSchemaFingerprint !== authorizedSchemaFingerprint) {
+                throw new Error(`Schema '${name}' changed on disk while initialization was being prepared. ` +
+                    'Aborted to preserve those concurrent changes.');
+            }
+            if (preparedConfig && !configMatchesPreparedState(preparedConfig)) {
+                throw new Error(`${path.basename(preparedConfig.path)} changed on disk while initialization was being prepared. ` +
+                    'Aborted to preserve those concurrent changes.');
+            }
+            const token = `${process.pid}-${Date.now()}`;
+            const schemaBackup = `${schemaDir}.init-backup-${token}`;
+            const configBackup = preparedConfig
+                ? `${preparedConfig.path}.init-backup-${token}`
+                : null;
+            let schemaBackedUp = false;
+            let configBackedUp = false;
+            let schemaInstalled = false;
+            let configInstalled = false;
             try {
-                fs.writeFileSync(path.join(schemaStagingDir, 'schema.yaml'), stringifyYaml(schema));
-                const templatesDir = path.join(schemaStagingDir, 'templates');
-                for (const artifact of selectedArtifacts) {
-                    const templatePath = path.join(templatesDir, artifact.template);
-                    fs.mkdirSync(path.dirname(templatePath), { recursive: true });
-                    fs.writeFileSync(templatePath, createDefaultTemplate(artifact.id));
-                }
-                const validation = validateSchema(schemaStagingDir);
-                if (!validation.valid) {
-                    throw new Error(`Generated schema failed validation: ${validation.issues
-                        .map((issue) => issue.message)
-                        .join('; ')}`);
-                }
-                if (preparedConfig) {
-                    const configDir = path.dirname(preparedConfig.path);
-                    configStagingDir = fs.mkdtempSync(path.join(configDir, '.schema-init-config-'));
-                    stagedConfigPath = path.join(configStagingDir, path.basename(preparedConfig.path));
-                    fs.writeFileSync(stagedConfigPath, preparedConfig.content);
-                    if (preparedConfig.originalMode !== null) {
-                        fs.chmodSync(stagedConfigPath, preparedConfig.originalMode);
-                    }
+                if (schemaExists) {
+                    schemaInitFileOperations.renameSync(schemaDir, schemaBackup);
+                    schemaBackedUp = true;
                 }
-                // Re-resolve both destinations immediately before the first move so
-                // a parent symlink swap during staging cannot redirect the commit.
-                FileSystemUtils.assertProjectArtifactPath(projectRoot, schemaDir);
-                if (preparedConfig) {
-                    FileSystemUtils.assertProjectArtifactPath(projectRoot, preparedConfig.path);
+                if (preparedConfig && preparedConfig.originalContent !== null) {
+                    schemaInitFileOperations.renameSync(preparedConfig.path, configBackup);
+                    configBackedUp = true;
                 }
-                const currentSchemaFingerprint = fs.existsSync(schemaDir)
-                    ? fingerprintDir(schemaDir)
-                    : null;
-                if (currentSchemaFingerprint !== authorizedSchemaFingerprint) {
-                    throw new Error(`Schema '${name}' changed on disk while initialization was being prepared. ` +
-                        'Aborted to preserve those concurrent changes.');
-                }
-                if (preparedConfig && !configMatchesPreparedState(preparedConfig)) {
-                    throw new Error(`${path.basename(preparedConfig.path)} changed on disk while initialization was being prepared. ` +
-                        'Aborted to preserve those concurrent changes.');
+                schemaInitFileOperations.renameSync(schemaStagingDir, schemaDir);
+                schemaInstalled = true;
+                if (preparedConfig && stagedConfigPath) {
+                    schemaInitFileOperations.renameSync(stagedConfigPath, preparedConfig.path);
+                    configInstalled = true;
                 }
-                const token = `${process.pid}-${Date.now()}`;
-                const schemaBackup = `${schemaDir}.init-backup-${token}`;
-                const configBackup = preparedConfig
-                    ? `${preparedConfig.path}.init-backup-${token}`
-                    : null;
-                let schemaBackedUp = false;
-                let configBackedUp = false;
-                let schemaInstalled = false;
-                let configInstalled = false;
+            }
+            catch (installError) {
+                const rollbackErrors = [];
                 try {
-                    if (schemaExists) {
-                        schemaInitFileOperations.renameSync(schemaDir, schemaBackup);
-                        schemaBackedUp = true;
-                    }
-                    if (preparedConfig && preparedConfig.originalContent !== null) {
-                        schemaInitFileOperations.renameSync(preparedConfig.path, configBackup);
-                        configBackedUp = true;
+                    if (configInstalled && preparedConfig) {
+                        fs.rmSync(preparedConfig.path, { force: true });
                     }
-                    schemaInitFileOperations.renameSync(schemaStagingDir, schemaDir);
-                    schemaInstalled = true;
-                    if (preparedConfig && stagedConfigPath) {
-                        schemaInitFileOperations.renameSync(stagedConfigPath, preparedConfig.path);
-                        configInstalled = true;
+                    if (configBackedUp && preparedConfig && configBackup) {
+                        schemaInitFileOperations.renameSync(configBackup, preparedConfig.path);
                     }
                 }
-                catch (installError) {
-                    const rollbackErrors = [];
-                    try {
-                        if (configInstalled && preparedConfig) {
-                            fs.rmSync(preparedConfig.path, { force: true });
-                        }
-                        if (configBackedUp && preparedConfig && configBackup) {
-                            schemaInitFileOperations.renameSync(configBackup, preparedConfig.path);
-                        }
-                    }
-                    catch (rollbackError) {
-                        rollbackErrors.push(`config: ${rollbackError.message}`);
-                    }
-                    try {
-                        if (schemaInstalled) {
-                            fs.rmSync(schemaDir, { recursive: true, force: true });
-                        }
-                        if (schemaBackedUp) {
-                            schemaInitFileOperations.renameSync(schemaBackup, schemaDir);
-                        }
-                    }
-                    catch (rollbackError) {
-                        rollbackErrors.push(`schema: ${rollbackError.message}`);
-                    }
-                    if (rollbackErrors.length > 0) {
-                        throw new Error(`Schema initialization failed and rollback was incomplete (${rollbackErrors.join(', ')}). ` +
-                            `Recovery backups may remain beside ${schemaDir} and ${preparedConfig?.path ?? 'the config file'}.`, { cause: installError });
-                    }
-                    throw installError;
+                catch (rollbackError) {
+                    rollbackErrors.push(`config: ${rollbackError.message}`);
                 }
-                // The transaction is committed. Cleanup cannot turn success into a
-                // false failure, so leave a recoverable backup and warn if removal is
-                // blocked instead of reporting that initialization failed.
-                for (const backup of [
-                    schemaBackedUp ? schemaBackup : null,
-                    configBackedUp ? configBackup : null,
-                ]) {
-                    if (!backup)
-                        continue;
-                    try {
-                        fs.rmSync(backup, { recursive: true, force: true });
+                try {
+                    if (schemaInstalled) {
+                        fs.rmSync(schemaDir, { recursive: true, force: true });
                     }
-                    catch (cleanupError) {
-                        console.error(`Warning: initialization succeeded, but the backup at ${backup} could not be removed: ${cleanupError.message}`);
+                    if (schemaBackedUp) {
+                        schemaInitFileOperations.renameSync(schemaBackup, schemaDir);
                     }
                 }
+                catch (rollbackError) {
+                    rollbackErrors.push(`schema: ${rollbackError.message}`);
+                }
+                if (rollbackErrors.length > 0) {
+                    throw new Error(`Schema initialization failed and rollback was incomplete (${rollbackErrors.join(', ')}). ` +
+                        `Recovery backups may remain beside ${schemaDir} and ${preparedConfig?.path ?? 'the config file'}.`, { cause: installError });
+                }
+                throw installError;
             }
-            catch (error) {
+            // The transaction is committed. Cleanup cannot turn success into a
+            // false failure, so leave a recoverable backup and warn if removal is
+            // blocked instead of reporting that initialization failed.
+            for (const backup of [
+                schemaBackedUp ? schemaBackup : null,
+                configBackedUp ? configBackup : null,
+            ]) {
+                if (!backup)
+                    continue;
                 try {
-                    fs.rmSync(schemaStagingDir, { recursive: true, force: true });
+                    fs.rmSync(backup, { recursive: true, force: true });
                 }
-                catch {
-                    // Best-effort cleanup must not hide the operation's real error.
+                catch (cleanupError) {
+                    console.error(`Warning: initialization succeeded, but the backup at ${backup} could not be removed: ${cleanupError.message}`);
                 }
-                throw error;
             }
-            finally {
-                if (configStagingDir) {
-                    try {
-                        fs.rmSync(configStagingDir, { recursive: true, force: true });
-                    }
-                    catch {
-                        // Best-effort cleanup. A committed config has already moved out.
-                    }
-                }
+        }
+        catch (error) {
+            try {
+                fs.rmSync(schemaStagingDir, { recursive: true, force: true });
             }
-            if (spinner)
-                spinner.succeed(`Created schema '${name}'`);
-            if (options?.json) {
-                console.log(JSON.stringify({
-                    created: true,
-                    path: schemaDir,
-                    schema: name,
-                    artifacts: selectedArtifactIds,
-                    setAsDefault: options?.default || false,
-                }, null, 2));
+            catch {
+                // Best-effort cleanup must not hide the operation's real error.
             }
-            else {
-                console.log(`\nSchema created at: ${schemaDir}`);
-                console.log(`\nArtifacts: ${selectedArtifactIds.join(', ')}`);
-                if (options?.default) {
-                    console.log(`\nSet as project default schema.`);
+            throw error;
+        }
+        finally {
+            if (configStagingDir) {
+                try {
+                    fs.rmSync(configStagingDir, { recursive: true, force: true });
+                }
+                catch {
+                    // Best-effort cleanup. A committed config has already moved out.
                 }
-                console.log(`\nNext steps:`);
-                console.log(`  1. Edit ${schemaDir}/schema.yaml to customize artifacts`);
-                console.log(`  2. Modify templates in the schema directory`);
-                console.log(`  3. Use with: openspec new --schema ${name}`);
             }
         }
-        catch (error) {
-            if (spinner)
-                spinner.fail(`Creation failed`);
-            if (options?.json) {
-                console.log(JSON.stringify({
-                    created: false,
-                    error: error.message,
-                }, null, 2));
-            }
-            else {
-                console.error(`Error: ${error.message}`);
+        if (spinner)
+            spinner.succeed(`Created schema '${name}'`);
+        if (options?.json) {
+            console.log(JSON.stringify({
+                created: true,
+                path: schemaDir,
+                schema: name,
+                artifacts: selectedArtifactIds,
+                setAsDefault: options?.default || false,
+            }, null, 2));
+        }
+        else {
+            console.log(`\nSchema created at: ${schemaDir}`);
+            console.log(`\nArtifacts: ${selectedArtifactIds.join(', ')}`);
+            if (options?.default) {
+                console.log(`\nSet as project default schema.`);
             }
-            process.exitCode = 1;
+            console.log(`\nNext steps:`);
+            console.log(`  1. Edit ${schemaDir}/schema.yaml to customize artifacts`);
+            console.log(`  2. Modify templates in the schema directory`);
+            console.log(`  3. Use with: openspec new --schema ${name}`);
         }
-    });
+    }
+    catch (error) {
+        if (spinner)
+            spinner.fail(`Creation failed`);
+        if (options?.json) {
+            console.log(JSON.stringify({
+                created: false,
+                error: error.message,
+            }, null, 2));
+        }
+        else {
+            console.error(`Error: ${error.message}`);
+        }
+        process.exitCode = 1;
+    }
 }
 /**
  * Create default template content for an artifact.