synarcx 0.2.0 → 0.3.0

package/dist/core/completions/installers/powershell-installer.d.ts

@@ -9,6 +9,7 @@ export declare class PowerShellInstaller {
      * Markers for PowerShell profile configuration management
      */
     private readonly PROFILE_MARKERS;
+    private readonly LEGACY_MARKERS;
     constructor(homeDir?: string);
     /**
      * Detect the encoding of a file by inspecting its BOM (Byte Order Mark).

package/dist/core/completions/installers/powershell-installer.js

@@ -11,6 +11,10 @@ export class PowerShellInstaller {
      * Markers for PowerShell profile configuration management
      */
     PROFILE_MARKERS = {
+        start: '# SYNARCX:START',
+        end: '# SYNARCX:END',
+    };
+    LEGACY_MARKERS = {
         start: '# OPENSPEC:START',
         end: '# OPENSPEC:END',
     };
@@ -107,7 +111,7 @@ export class PowerShellInstaller {
     getInstallationPath() {
         const profilePath = this.getProfilePath();
         const profileDir = path.dirname(profilePath);
-        return path.join(profileDir, 'OpenSpecCompletion.ps1');
+        return path.join(profileDir, 'SynArcXCompletion.ps1');
     }
     /**
      * Backup an existing completion file if it exists
@@ -182,15 +186,15 @@ export class PowerShellInstaller {
                 if (profileContent.includes(scriptLine)) {
                     continue; // Already configured, skip
                 }
-                // Add OpenSpec completion configuration with markers
-                const openspecBlock = [
+                // Add synarcx completion configuration with markers
+                const synarcxBlock = [
                     '',
-                    '# OPENSPEC:START - synarcx completion (managed block, do not edit manually)',
+                    this.PROFILE_MARKERS.start + ' - synarcx completion (managed block, do not edit manually)',
                     scriptLine,
-                    '# OPENSPEC:END',
+                    this.PROFILE_MARKERS.end,
                     '',
                 ].join('\n');
-                const newContent = profileContent + openspecBlock;
+                const newContent = profileContent + synarcxBlock;
                 await this.writeProfileFile(profilePath, newContent, fileEncoding, fileBom);
                 anyConfigured = true;
             }
@@ -229,12 +233,16 @@ export class PowerShellInstaller {
                     console.warn(`Warning: Could not read ${profilePath}: ${err?.message ?? String(err)}`);
                     continue;
                 }
-                // Remove OPENSPEC:START -> OPENSPEC:END block
-                const startMarker = '# OPENSPEC:START';
-                const endMarker = '# OPENSPEC:END';
+                // Determine which markers to use (check new first, fall back to legacy)
+                const startMarker = profileContent.includes(this.PROFILE_MARKERS.start)
+                    ? this.PROFILE_MARKERS.start
+                    : this.LEGACY_MARKERS.start;
+                const endMarker = profileContent.includes(this.PROFILE_MARKERS.end)
+                    ? this.PROFILE_MARKERS.end
+                    : this.LEGACY_MARKERS.end;
                 const startIndex = profileContent.indexOf(startMarker);
                 if (startIndex === -1) {
-                    continue; // No OpenSpec block found
+                    continue; // No synarcx block found
                 }
                 const endIndex = profileContent.indexOf(endMarker, startIndex);
                 if (endIndex === -1) {

package/dist/core/config.js

@@ -11,7 +11,6 @@ export const AI_TOOLS = [
     { name: 'Claude Code', value: 'claude', available: true, successLabel: 'Claude Code', skillsDir: '.claude', hasCommands: true },
     { name: 'Cline', value: 'cline', available: true, successLabel: 'Cline', skillsDir: '.cline' },
     { name: 'Codex', value: 'codex', available: true, successLabel: 'Codex', skillsDir: '.codex' },
-    { name: 'ForgeCode', value: 'forgecode', available: true, successLabel: 'ForgeCode', skillsDir: '.forge' },
     { name: 'CodeBuddy Code (CLI)', value: 'codebuddy', available: true, successLabel: 'CodeBuddy Code', skillsDir: '.codebuddy' },
     { name: 'Continue', value: 'continue', available: true, successLabel: 'Continue (VS Code / JetBrains / Cli)', skillsDir: '.continue' },
     { name: 'CoStrict', value: 'costrict', available: true, successLabel: 'CoStrict', skillsDir: '.cospec' },
@@ -23,7 +22,6 @@ export const AI_TOOLS = [
     { name: 'iFlow', value: 'iflow', available: true, successLabel: 'iFlow', skillsDir: '.iflow' },
     { name: 'Junie', value: 'junie', available: true, successLabel: 'Junie', skillsDir: '.junie' },
     { name: 'Kilo Code', value: 'kilocode', available: true, successLabel: 'Kilo Code', skillsDir: '.kilocode' },
-    { name: 'Kimi CLI', value: 'kimi', available: true, successLabel: 'Kimi CLI', skillsDir: '.kimi' },
     { name: 'Kiro', value: 'kiro', available: true, successLabel: 'Kiro', skillsDir: '.kiro' },
     { name: 'OpenCode', value: 'opencode', available: true, successLabel: 'OpenCode', skillsDir: '.opencode', hasCommands: true },
     { name: 'Pi', value: 'pi', available: true, successLabel: 'Pi', skillsDir: '.pi' },
@@ -31,7 +29,6 @@ export const AI_TOOLS = [
     { name: 'Lingma', value: 'lingma', available: true, successLabel: 'Lingma', skillsDir: '.lingma' },
     { name: 'Qwen Code', value: 'qwen', available: true, successLabel: 'Qwen Code', skillsDir: '.qwen' },
     { name: 'RooCode', value: 'roocode', available: true, successLabel: 'RooCode', skillsDir: '.roo' },
-    { name: 'Trae', value: 'trae', available: true, successLabel: 'Trae', skillsDir: '.trae' },
     { name: 'Windsurf', value: 'windsurf', available: true, successLabel: 'Windsurf', skillsDir: '.windsurf' },
     { name: 'AGENTS.md (works with Amp, VS Code, …)', value: 'agents', available: false, successLabel: 'your AGENTS.md-compatible assistant' }
 ];

package/dist/core/index.js

@@ -1,4 +1,4 @@
-// Core OpenSpec logic will be implemented here
+// Core synarcx logic will be implemented here
 export { GLOBAL_CONFIG_DIR_NAME, GLOBAL_CONFIG_FILE_NAME, GLOBAL_DATA_DIR_NAME, getGlobalConfigDir, getGlobalConfigPath, getGlobalConfig, saveGlobalConfig, getGlobalDataDir } from './global-config.js';
 export * from './workspace/index.js';
 //# sourceMappingURL=index.js.map

package/dist/core/init.d.ts

@@ -30,8 +30,6 @@ export declare class InitCommand {
     private createConfig;
     private displaySuccessMessage;
     private startSpinner;
-    private removeSkillDirs;
-    private removeCommandFiles;
 }
 export {};
 //# sourceMappingURL=init.d.ts.map

package/dist/core/init.js

@@ -19,31 +19,20 @@ import { generateCommands, CommandAdapterRegistry, } from './command-generation/
 import { detectLegacyArtifacts, cleanupLegacyArtifacts, formatCleanupSummary, formatDetectionSummary, } from './legacy-cleanup.js';
 import { getToolsWithSkillsDir, getToolStates, getSkillTemplates, getCommandContents, generateSkillContent, } from './shared/index.js';
 import { getGlobalConfig } from './global-config.js';
-import { getProfileWorkflows, ALL_WORKFLOWS } from './profiles.js';
+import { getProfileWorkflows } from './profiles.js';
+import { DEFAULT_SCHEMA } from './shared/workflow-registry.js';
+import { removeSkillDirs, removeCommandFiles } from './shared/artifact-cleanup.js';
 import { getAvailableTools } from './available-tools.js';
 import { migrateIfNeeded } from './migration.js';
 const require = createRequire(import.meta.url);
-const { version: SYNC_VERSION } = require('../../package.json');
+const { version: SYNARCX_VERSION } = require('../../package.json');
 // -----------------------------------------------------------------------------
 // Constants
 // -----------------------------------------------------------------------------
-const DEFAULT_SCHEMA = 'synarcx';
 const PROGRESS_SPINNER = {
     interval: 80,
     frames: ['░░░', '▒░░', '▒▒░', '▒▒▒', '▓▒▒', '▓▓▒', '▓▓▓', '▒▓▓', '░▒▓'],
 };
-const WORKFLOW_TO_SKILL_DIR = {
-    'explore': 'syn-explore',
-    'apply': 'syn-apply',
-    'archive': 'syn-archive',
-    'propose': 'syn-propose',
-    'sync': 'syn-sync',
-    'clarify': 'syn-clarify',
-    'analyze': 'syn-analyze',
-    'debug': 'syn-debug',
-    'refactor': 'syn-refactor',
-    'quick': 'syn-quick',
-};
 // -----------------------------------------------------------------------------
 // Init Command Class
 // -----------------------------------------------------------------------------
@@ -60,10 +49,10 @@ export class InitCommand {
     }
     async execute(targetPath) {
         const projectPath = path.resolve(targetPath);
-        const openspecDir = SYNSPEC_DIR_NAME;
-        const openspecPath = path.join(projectPath, openspecDir);
+        const synspecDir = SYNSPEC_DIR_NAME;
+        const synspecPath = path.join(projectPath, synspecDir);
         // Validation happens silently in the background
-        const extendMode = await this.validate(projectPath, openspecPath);
+        const extendMode = await this.validate(projectPath, synspecPath);
         // Check for legacy artifacts and handle cleanup
         await this.handleLegacyCleanup(projectPath, extendMode);
         // Detect available tools in the project (task 7.1)
@@ -88,19 +77,19 @@ export class InitCommand {
         // Validate selected tools
         const validatedTools = this.validateTools(selectedToolIds, toolStates);
         // Create directory structure and config
-        await this.createDirectoryStructure(openspecPath, extendMode);
+        await this.createDirectoryStructure(synspecPath, extendMode);
         // Generate skills and commands for each tool
         const results = await this.generateSkillsAndCommands(projectPath, validatedTools);
         // Create config.yaml if needed
-        const configStatus = await this.createConfig(openspecPath, extendMode);
+        const configStatus = await this.createConfig(synspecPath, extendMode);
         // Display success message
         this.displaySuccessMessage(projectPath, validatedTools, results, configStatus);
     }
     // ═══════════════════════════════════════════════════════════
     // VALIDATION & SETUP
     // ═══════════════════════════════════════════════════════════
-    async validate(projectPath, openspecPath) {
-        const extendMode = await FileSystemUtils.directoryExists(openspecPath);
+    async validate(projectPath, synspecPath) {
+        const extendMode = await FileSystemUtils.directoryExists(synspecPath);
         // Check write permissions
         if (!(await FileSystemUtils.ensureWritePermissions(projectPath))) {
             throw new Error(`Insufficient permissions to write to ${projectPath}`);
@@ -139,7 +128,7 @@ export class InitCommand {
         const canPrompt = this.canPromptInteractively();
         if (this.force || !canPrompt) {
             // --force flag or non-interactive mode: proceed with cleanup automatically.
-            // Legacy slash commands are 100% OpenSpec-managed, and config file cleanup
+            // Legacy slash commands are 100% synarcx-managed, and config file cleanup
             // only removes markers (never deletes files), so auto-cleanup is safe.
             await this.performLegacyCleanup(projectPath, detection);
             return;
@@ -316,14 +305,14 @@ export class InitCommand {
     // ═══════════════════════════════════════════════════════════
     // DIRECTORY STRUCTURE
     // ═══════════════════════════════════════════════════════════
-    async createDirectoryStructure(openspecPath, extendMode) {
+    async createDirectoryStructure(synspecPath, extendMode) {
         if (extendMode) {
             // In extend mode, just ensure directories exist without spinner
             const directories = [
-                openspecPath,
-                path.join(openspecPath, 'specs'),
-                path.join(openspecPath, 'changes'),
-                path.join(openspecPath, 'changes', 'archive'),
+                synspecPath,
+                path.join(synspecPath, 'specs'),
+                path.join(synspecPath, 'changes'),
+                path.join(synspecPath, 'changes', 'archive'),
             ];
             for (const dir of directories) {
                 await FileSystemUtils.createDirectory(dir);
@@ -332,10 +321,10 @@ export class InitCommand {
         }
         const spinner = this.startSpinner('Creating synarcx structure...');
         const directories = [
-            openspecPath,
-            path.join(openspecPath, 'specs'),
-            path.join(openspecPath, 'changes'),
-            path.join(openspecPath, 'changes', 'archive'),
+            synspecPath,
+            path.join(synspecPath, 'specs'),
+            path.join(synspecPath, 'changes'),
+            path.join(synspecPath, 'changes', 'archive'),
         ];
         for (const dir of directories) {
             await FileSystemUtils.createDirectory(dir);
@@ -383,14 +372,14 @@ export class InitCommand {
                         // Generate SKILL.md content with YAML frontmatter including generatedBy
                         // Use hyphen-based command references for tools where filename = command name
                         const transformer = tool.value === 'pi' ? transformToHyphenCommands : undefined;
-                        const skillContent = generateSkillContent(template, SYNC_VERSION, transformer);
+                        const skillContent = generateSkillContent(template, SYNARCX_VERSION, transformer);
                         // Write the skill file
                         await FileSystemUtils.writeFile(skillFile, skillContent);
                     }
                 }
                 if (!generateSkillsForTool) {
                     const skillsDir = path.join(projectPath, tool.skillsDir, 'skills');
-                    removedSkillCount += await this.removeSkillDirs(skillsDir);
+                    removedSkillCount += await removeSkillDirs(skillsDir);
                 }
                 // Generate commands if delivery includes commands
                 if (shouldGenerateCommands) {
@@ -407,7 +396,7 @@ export class InitCommand {
                     }
                 }
                 if (!shouldGenerateCommands) {
-                    removedCommandCount += await this.removeCommandFiles(projectPath, tool.value);
+                    removedCommandCount += await removeCommandFiles(projectPath, tool.value);
                 }
                 spinner.succeed(`Setup complete for ${tool.name}`);
                 if (tool.wasConfigured) {
@@ -434,9 +423,9 @@ export class InitCommand {
     // ═══════════════════════════════════════════════════════════
     // CONFIG FILE
     // ═══════════════════════════════════════════════════════════
-    async createConfig(openspecPath, extendMode) {
-        const configPath = path.join(openspecPath, 'config.yaml');
-        const configYmlPath = path.join(openspecPath, 'config.yml');
+    async createConfig(synspecPath, extendMode) {
+        const configPath = path.join(synspecPath, 'config.yaml');
+        const configYmlPath = path.join(synspecPath, 'config.yml');
         const configYamlExists = fs.existsSync(configPath);
         const configYmlExists = fs.existsSync(configYmlPath);
         if (configYamlExists || configYmlExists) {
@@ -544,44 +533,5 @@ export class InitCommand {
             spinner: PROGRESS_SPINNER,
         }).start();
     }
-    async removeSkillDirs(skillsDir) {
-        let removed = 0;
-        for (const workflow of ALL_WORKFLOWS) {
-            const dirName = WORKFLOW_TO_SKILL_DIR[workflow];
-            if (!dirName)
-                continue;
-            const skillDir = path.join(skillsDir, dirName);
-            try {
-                if (fs.existsSync(skillDir)) {
-                    await fs.promises.rm(skillDir, { recursive: true, force: true });
-                    removed++;
-                }
-            }
-            catch {
-                // Ignore errors
-            }
-        }
-        return removed;
-    }
-    async removeCommandFiles(projectPath, toolId) {
-        let removed = 0;
-        const adapter = CommandAdapterRegistry.get(toolId);
-        if (!adapter)
-            return 0;
-        for (const workflow of ALL_WORKFLOWS) {
-            const cmdPath = adapter.getFilePath(workflow);
-            const fullPath = path.isAbsolute(cmdPath) ? cmdPath : path.join(projectPath, cmdPath);
-            try {
-                if (fs.existsSync(fullPath)) {
-                    await fs.promises.unlink(fullPath);
-                    removed++;
-                }
-            }
-            catch {
-                // Ignore errors
-            }
-        }
-        return removed;
-    }
 }
 //# sourceMappingURL=init.js.map

package/dist/core/migration.js

@@ -6,8 +6,7 @@
  */
 import { getGlobalConfig, getGlobalConfigPath, saveGlobalConfig } from './global-config.js';
 import { CommandAdapterRegistry } from './command-generation/index.js';
-import { WORKFLOW_TO_SKILL_DIR } from './profile-sync-drift.js';
-import { ALL_WORKFLOWS } from './profiles.js';
+import { ALL_WORKFLOWS, WORKFLOW_TO_SKILL_DIR } from './shared/workflow-registry.js';
 import path from 'path';
 import * as fs from 'fs';
 function scanInstalledWorkflowArtifacts(projectPath, tools) {

package/dist/core/profile-sync-drift.d.ts

@@ -1,10 +1,4 @@
 import type { Delivery } from './global-config.js';
-import { ALL_WORKFLOWS } from './profiles.js';
-type WorkflowId = (typeof ALL_WORKFLOWS)[number];
-/**
- * Maps workflow IDs to their skill directory names.
- */
-export declare const WORKFLOW_TO_SKILL_DIR: Record<WorkflowId, string>;
 /**
  * Checks whether a tool has at least one generated synarcx command file.
  */
@@ -34,5 +28,4 @@ export declare function getToolsNeedingProfileSync(projectPath: string, desiredW
  * Detects whether the current project has any profile/delivery drift.
  */
 export declare function hasProjectConfigDrift(projectPath: string, desiredWorkflows: readonly string[], delivery: Delivery): boolean;
-export {};
 //# sourceMappingURL=profile-sync-drift.d.ts.map

package/dist/core/profile-sync-drift.js

@@ -1,24 +1,9 @@
 import path from 'path';
 import * as fs from 'fs';
 import { AI_TOOLS } from './config.js';
-import { ALL_WORKFLOWS } from './profiles.js';
+import { ALL_WORKFLOWS, WORKFLOW_TO_SKILL_DIR, COMMAND_IDS } from './shared/workflow-registry.js';
 import { CommandAdapterRegistry } from './command-generation/index.js';
-import { COMMAND_IDS, getConfiguredTools } from './shared/index.js';
-/**
- * Maps workflow IDs to their skill directory names.
- */
-export const WORKFLOW_TO_SKILL_DIR = {
-    'explore': 'syn-explore',
-    'apply': 'syn-apply',
-    'archive': 'syn-archive',
-    'propose': 'syn-propose',
-    'sync': 'syn-sync',
-    'clarify': 'syn-clarify',
-    'analyze': 'syn-analyze',
-    'debug': 'syn-debug',
-    'refactor': 'syn-refactor',
-    'quick': 'syn-quick',
-};
+import { getConfiguredTools } from './shared/index.js';
 function toKnownWorkflows(workflows) {
     return workflows.filter((workflow) => ALL_WORKFLOWS.includes(workflow));
 }

package/dist/core/profiles.d.ts

@@ -5,17 +5,6 @@
  * Profiles determine WHICH workflows; delivery (in global config) determines HOW.
  */
 import type { Profile } from './global-config.js';
-/**
- * Core workflows included in the 'core' profile.
- * These provide the streamlined experience for new users.
- */
-export declare const CORE_WORKFLOWS: readonly ["explore", "propose", "clarify", "analyze", "apply", "debug", "archive", "sync", "refactor", "quick"];
-/**
- * All available workflows in the system.
- */
-export declare const ALL_WORKFLOWS: readonly ["explore", "propose", "clarify", "analyze", "apply", "debug", "archive", "sync", "refactor", "quick"];
-export type WorkflowId = (typeof ALL_WORKFLOWS)[number];
-export type CoreWorkflowId = (typeof CORE_WORKFLOWS)[number];
 /**
  * Resolves which workflows should be active for a given profile configuration.
  *

package/dist/core/profiles.js

@@ -4,26 +4,7 @@
  * Defines workflow profiles that control which workflows are installed.
  * Profiles determine WHICH workflows; delivery (in global config) determines HOW.
  */
-/**
- * Core workflows included in the 'core' profile.
- * These provide the streamlined experience for new users.
- */
-export const CORE_WORKFLOWS = ['explore', 'propose', 'clarify', 'analyze', 'apply', 'debug', 'archive', 'sync', 'refactor', 'quick'];
-/**
- * All available workflows in the system.
- */
-export const ALL_WORKFLOWS = [
-    'explore',
-    'propose',
-    'clarify',
-    'analyze',
-    'apply',
-    'debug',
-    'archive',
-    'sync',
-    'refactor',
-    'quick',
-];
+import { CORE_WORKFLOWS } from './shared/workflow-registry.js';
 /**
  * Resolves which workflows should be active for a given profile configuration.
  *

package/dist/core/shared/artifact-cleanup.d.ts

@@ -0,0 +1,5 @@
+export declare function removeSkillDirs(skillsDir: string): Promise<number>;
+export declare function removeUnselectedSkillDirs(skillsDir: string, desiredWorkflows: readonly string[]): Promise<number>;
+export declare function removeCommandFiles(projectPath: string, toolId: string): Promise<number>;
+export declare function removeUnselectedCommandFiles(projectPath: string, toolId: string, desiredWorkflows: readonly string[]): Promise<number>;
+//# sourceMappingURL=artifact-cleanup.d.ts.map

package/dist/core/shared/artifact-cleanup.js

@@ -0,0 +1,89 @@
+import path from 'path';
+import * as fs from 'fs';
+import { ALL_WORKFLOWS, WORKFLOW_TO_SKILL_DIR } from './workflow-registry.js';
+import { CommandAdapterRegistry } from '../command-generation/index.js';
+export async function removeSkillDirs(skillsDir) {
+    let removed = 0;
+    for (const workflow of ALL_WORKFLOWS) {
+        const dirName = WORKFLOW_TO_SKILL_DIR[workflow];
+        if (!dirName)
+            continue;
+        const skillDir = path.join(skillsDir, dirName);
+        try {
+            if (fs.existsSync(skillDir)) {
+                await fs.promises.rm(skillDir, { recursive: true, force: true });
+                removed++;
+            }
+        }
+        catch {
+            // Ignore errors
+        }
+    }
+    return removed;
+}
+export async function removeUnselectedSkillDirs(skillsDir, desiredWorkflows) {
+    const desiredSet = new Set(desiredWorkflows);
+    let removed = 0;
+    for (const workflow of ALL_WORKFLOWS) {
+        if (desiredSet.has(workflow))
+            continue;
+        const dirName = WORKFLOW_TO_SKILL_DIR[workflow];
+        if (!dirName)
+            continue;
+        const skillDir = path.join(skillsDir, dirName);
+        try {
+            if (fs.existsSync(skillDir)) {
+                await fs.promises.rm(skillDir, { recursive: true, force: true });
+                removed++;
+            }
+        }
+        catch {
+            // Ignore errors
+        }
+    }
+    return removed;
+}
+export async function removeCommandFiles(projectPath, toolId) {
+    let removed = 0;
+    const adapter = CommandAdapterRegistry.get(toolId);
+    if (!adapter)
+        return 0;
+    for (const workflow of ALL_WORKFLOWS) {
+        const cmdPath = adapter.getFilePath(workflow);
+        const fullPath = path.isAbsolute(cmdPath) ? cmdPath : path.join(projectPath, cmdPath);
+        try {
+            if (fs.existsSync(fullPath)) {
+                await fs.promises.unlink(fullPath);
+                removed++;
+            }
+        }
+        catch {
+            // Ignore errors
+        }
+    }
+    return removed;
+}
+export async function removeUnselectedCommandFiles(projectPath, toolId, desiredWorkflows) {
+    let removed = 0;
+    const adapter = CommandAdapterRegistry.get(toolId);
+    if (!adapter)
+        return 0;
+    const desiredSet = new Set(desiredWorkflows);
+    for (const workflow of ALL_WORKFLOWS) {
+        if (desiredSet.has(workflow))
+            continue;
+        const cmdPath = adapter.getFilePath(workflow);
+        const fullPath = path.isAbsolute(cmdPath) ? cmdPath : path.join(projectPath, cmdPath);
+        try {
+            if (fs.existsSync(fullPath)) {
+                await fs.promises.unlink(fullPath);
+                removed++;
+            }
+        }
+        catch {
+            // Ignore errors
+        }
+    }
+    return removed;
+}
+//# sourceMappingURL=artifact-cleanup.js.map

package/dist/core/shared/skill-generation.js

@@ -3,7 +3,7 @@
  *
  * Shared utilities for generating skill and command files.
  */
-import { getSynExploreSkillTemplate, getSynApplySkillTemplate, getSynArchiveSkillTemplate, getSynProposeSkillTemplate, getSynSyncSkillTemplate, getSynClarifySkillTemplate, getSynAnalyzeSkillTemplate, getSynDebugSkillTemplate, getSynRefactorSkillTemplate, getSynQuickSkillTemplate, getSynExploreCommandTemplate, getSynApplyCommandTemplate, getSynArchiveCommandTemplate, getSynProposeCommandTemplate, getSynSyncCommandTemplate, getSynClarifyCommandTemplate, getSynAnalyzeCommandTemplate, getSynDebugCommandTemplate, getSynRefactorCommandTemplate, getSynQuickCommandTemplate, } from '../templates/skill-templates.js';
+import { getSynExploreSkillTemplate, getSynApplySkillTemplate, getSynProposeSkillTemplate, getSynSyncSkillTemplate, getSynClarifySkillTemplate, getSynAnalyzeSkillTemplate, getSynDebugSkillTemplate, getSynRefactorSkillTemplate, getSynQuickSkillTemplate, getSynReviewSkillTemplate, getSynExploreCommandTemplate, getSynApplyCommandTemplate, getSynProposeCommandTemplate, getSynSyncCommandTemplate, getSynClarifyCommandTemplate, getSynAnalyzeCommandTemplate, getSynDebugCommandTemplate, getSynRefactorCommandTemplate, getSynQuickCommandTemplate, getSynReviewCommandTemplate, } from '../templates/skill-templates.js';
 /**
  * Gets skill templates with their directory names, optionally filtered by workflow IDs.
  *
@@ -13,7 +13,6 @@ export function getSkillTemplates(workflowFilter) {
     const all = [
         { template: getSynExploreSkillTemplate(), dirName: 'syn-explore', workflowId: 'explore' },
         { template: getSynApplySkillTemplate(), dirName: 'syn-apply', workflowId: 'apply' },
-        { template: getSynArchiveSkillTemplate(), dirName: 'syn-archive', workflowId: 'archive' },
         { template: getSynProposeSkillTemplate(), dirName: 'syn-propose', workflowId: 'propose' },
         { template: getSynSyncSkillTemplate(), dirName: 'syn-sync', workflowId: 'sync' },
         { template: getSynClarifySkillTemplate(), dirName: 'syn-clarify', workflowId: 'clarify' },
@@ -21,6 +20,7 @@ export function getSkillTemplates(workflowFilter) {
         { template: getSynDebugSkillTemplate(), dirName: 'syn-debug', workflowId: 'debug' },
         { template: getSynRefactorSkillTemplate(), dirName: 'syn-refactor', workflowId: 'refactor' },
         { template: getSynQuickSkillTemplate(), dirName: 'syn-quick', workflowId: 'quick' },
+        { template: getSynReviewSkillTemplate(), dirName: 'syn-review', workflowId: 'review' },
     ];
     if (!workflowFilter)
         return all;
@@ -36,7 +36,6 @@ export function getCommandTemplates(workflowFilter) {
     const all = [
         { template: getSynExploreCommandTemplate(), id: 'explore' },
         { template: getSynApplyCommandTemplate(), id: 'apply' },
-        { template: getSynArchiveCommandTemplate(), id: 'archive' },
         { template: getSynProposeCommandTemplate(), id: 'propose' },
         { template: getSynSyncCommandTemplate(), id: 'sync' },
         { template: getSynClarifyCommandTemplate(), id: 'clarify' },
@@ -44,6 +43,7 @@ export function getCommandTemplates(workflowFilter) {
         { template: getSynDebugCommandTemplate(), id: 'debug' },
         { template: getSynRefactorCommandTemplate(), id: 'refactor' },
         { template: getSynQuickCommandTemplate(), id: 'quick' },
+        { template: getSynReviewCommandTemplate(), id: 'review' },
     ];
     if (!workflowFilter)
         return all;

package/dist/core/shared/tool-detection.d.ts

@@ -3,16 +3,10 @@
  *
  * Shared utilities for detecting tool configurations and version status.
  */
-/**
- * Names of skill directories created by synarcx init.
- */
-export declare const SKILL_NAMES: readonly ["syn-explore", "syn-apply", "syn-archive", "syn-propose", "syn-sync", "syn-clarify", "syn-analyze", "syn-debug", "syn-refactor", "syn-quick"];
-export type SkillName = (typeof SKILL_NAMES)[number];
-/**
- * IDs of command templates created by synarcx init.
- */
-export declare const COMMAND_IDS: readonly ["explore", "apply", "archive", "propose", "sync", "clarify", "analyze", "debug", "refactor", "quick"];
-export type CommandId = (typeof COMMAND_IDS)[number];
+import { SKILL_NAMES, COMMAND_IDS } from './workflow-registry.js';
+export type SkillName = string;
+export type CommandId = string;
+export { SKILL_NAMES, COMMAND_IDS };
 /**
  * Status of skill configuration for a tool.
  */

package/dist/core/shared/tool-detection.js

@@ -6,36 +6,8 @@
 import path from 'path';
 import * as fs from 'fs';
 import { AI_TOOLS } from '../config.js';
-/**
- * Names of skill directories created by synarcx init.
- */
-export const SKILL_NAMES = [
-    'syn-explore',
-    'syn-apply',
-    'syn-archive',
-    'syn-propose',
-    'syn-sync',
-    'syn-clarify',
-    'syn-analyze',
-    'syn-debug',
-    'syn-refactor',
-    'syn-quick',
-];
-/**
- * IDs of command templates created by synarcx init.
- */
-export const COMMAND_IDS = [
-    'explore',
-    'apply',
-    'archive',
-    'propose',
-    'sync',
-    'clarify',
-    'analyze',
-    'debug',
-    'refactor',
-    'quick',
-];
+import { SKILL_NAMES, COMMAND_IDS } from './workflow-registry.js';
+export { SKILL_NAMES, COMMAND_IDS };
 /**
  * Gets the list of tools with skillsDir configured.
  */
@@ -90,7 +62,7 @@ export function extractGeneratedByVersion(skillFilePath) {
         // ---
         // ...
         // metadata:
-        //   author: openspec
+        //   author: synarcx
         //   version: "1.0"
         //   generatedBy: "0.23.0"
         // ---