@dynamicworks/br-openspec 2.0.0 → 2.0.1

package/dist/core/artifact-graph/instruction-loader.js

@@ -4,7 +4,7 @@ import { getSchemaDir, resolveSchema } from './resolver.js';
 import { ArtifactGraph } from './graph.js';
 import { detectCompleted } from './state.js';
 import { resolveSchemaForChange } from '../../utils/change-metadata.js';
-import { WORKFLOW_MESSAGES } from '../../messages/index.js';
+import { WORKFLOW_MESSAGES, ARTIFACT_GRAPH_MESSAGES } from '../../messages/index.js';
 import { FileSystemUtils } from '../../utils/file-system.js';
 import { readProjectConfig, validateConfigRules } from '../project-config.js';
 // Session-level cache for validation warnings (avoid repeating same warnings)
@@ -36,7 +36,7 @@ export function loadTemplate(schemaName, templatePath, projectRoot) {
     }
     const templatePathOnDisk = path.join(schemaDir, 'templates', templatePath);
     if (!fs.existsSync(templatePathOnDisk)) {
-        throw new TemplateLoadError(`Template not found: ${templatePathOnDisk}`, templatePathOnDisk);
+        throw new TemplateLoadError(ARTIFACT_GRAPH_MESSAGES.templateNotFound(templatePathOnDisk), templatePathOnDisk);
     }
     const fullPath = FileSystemUtils.canonicalizeExistingPath(templatePathOnDisk);
     try {
@@ -44,7 +44,7 @@ export function loadTemplate(schemaName, templatePath, projectRoot) {
     }
     catch (err) {
         const ioError = err instanceof Error ? err : new Error(String(err));
-        throw new TemplateLoadError(`Failed to read template: ${ioError.message}`, fullPath);
+        throw new TemplateLoadError(ARTIFACT_GRAPH_MESSAGES.failedToReadTemplate(ioError.message), fullPath);
     }
 }
 /**
@@ -93,7 +93,7 @@ export function loadChangeContext(projectRoot, changeName, schemaName) {
 export function generateInstructions(context, artifactId, projectRoot) {
     const artifact = context.graph.getArtifact(artifactId);
     if (!artifact) {
-        throw new Error(`Artifact '${artifactId}' not found in schema '${context.schemaName}'`);
+        throw new Error(ARTIFACT_GRAPH_MESSAGES.artifactNotFound(artifactId, context.schemaName));
     }
     const templateContent = loadTemplate(context.schemaName, artifact.template, context.projectRoot);
     const dependencies = getDependencyInfo(artifact, context.graph, context.completed);

package/dist/core/artifact-graph/schema.js

@@ -1,6 +1,7 @@
 import * as fs from 'node:fs';
 import { parse as parseYaml } from 'yaml';
 import { SchemaYamlSchema } from './types.js';
+import { ARTIFACT_GRAPH_MESSAGES } from '../../messages/index.js';
 export class SchemaValidationError extends Error {
     constructor(message) {
         super(message);
@@ -23,7 +24,7 @@ export function parseSchema(yamlContent) {
     const result = SchemaYamlSchema.safeParse(parsed);
     if (!result.success) {
         const errors = result.error.issues.map(e => `${e.path.join('.')}: ${e.message}`).join(', ');
-        throw new SchemaValidationError(`Invalid schema: ${errors}`);
+        throw new SchemaValidationError(ARTIFACT_GRAPH_MESSAGES.invalidSchema(errors));
     }
     const schema = result.data;
     // Check for duplicate artifact IDs
@@ -41,7 +42,7 @@ function validateNoDuplicateIds(artifacts) {
     const seen = new Set();
     for (const artifact of artifacts) {
         if (seen.has(artifact.id)) {
-            throw new SchemaValidationError(`Duplicate artifact ID: ${artifact.id}`);
+            throw new SchemaValidationError(ARTIFACT_GRAPH_MESSAGES.duplicateArtifactId(artifact.id));
         }
         seen.add(artifact.id);
     }
@@ -54,7 +55,7 @@ function validateRequiresReferences(artifacts) {
     for (const artifact of artifacts) {
         for (const req of artifact.requires) {
             if (!validIds.has(req)) {
-                throw new SchemaValidationError(`Invalid dependency reference in artifact '${artifact.id}': '${req}' does not exist`);
+                throw new SchemaValidationError(ARTIFACT_GRAPH_MESSAGES.invalidDependencyReference(artifact.id, req));
             }
         }
     }
@@ -100,7 +101,7 @@ function validateNoCycles(artifacts) {
         if (!visited.has(artifact.id)) {
             const cycle = dfs(artifact.id);
             if (cycle) {
-                throw new SchemaValidationError(`Cyclic dependency detected: ${cycle}`);
+                throw new SchemaValidationError(ARTIFACT_GRAPH_MESSAGES.cyclicDependency(cycle));
             }
         }
     }

package/dist/core/completions/factory.js

@@ -6,6 +6,7 @@ import { ZshInstaller } from './installers/zsh-installer.js';
 import { BashInstaller } from './installers/bash-installer.js';
 import { FishInstaller } from './installers/fish-installer.js';
 import { PowerShellInstaller } from './installers/powershell-installer.js';
+import { COMPLETIONS_FACTORY_MESSAGES } from '../../messages/index.js';
 /**
  * Factory for creating completion generators and installers
  * This design makes it easy to add support for additional shells
@@ -30,7 +31,7 @@ export class CompletionFactory {
             case 'powershell':
                 return new PowerShellGenerator();
             default:
-                throw new Error(`Unsupported shell: ${shell}`);
+                throw new Error(COMPLETIONS_FACTORY_MESSAGES.unsupportedShell(shell));
         }
     }
     /**
@@ -51,7 +52,7 @@ export class CompletionFactory {
             case 'powershell':
                 return new PowerShellInstaller();
             default:
-                throw new Error(`Unsupported shell: ${shell}`);
+                throw new Error(COMPLETIONS_FACTORY_MESSAGES.unsupportedShell(shell));
         }
     }
     /**

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

@@ -1,6 +1,7 @@
 import { promises as fs } from 'fs';
 import path from 'path';
 import os from 'os';
+import { COMPLETION_MESSAGES } from '../../../messages/index.js';
 /**
  * Installer for Fish completion scripts.
  * Fish automatically loads completions from ~/.config/fish/completions/
@@ -56,10 +57,10 @@ export class FishInstaller {
                     return {
                         success: true,
                         installedPath: targetPath,
-                        message: 'Completion script is already installed (up to date)',
+                        message: COMPLETION_MESSAGES.fishAlreadyInstalled,
                         instructions: [
-                            'The completion script is already installed and up to date.',
-                            'Fish automatically loads completions - they should be available immediately.',
+                            COMPLETION_MESSAGES.fishAlreadyInstalledDetail,
+                            COMPLETION_MESSAGES.fishAutoLoadsHint,
                         ],
                     };
                 }
@@ -81,11 +82,11 @@ export class FishInstaller {
             let message;
             if (isUpdate) {
                 message = backupPath
-                    ? 'Completion script updated successfully (previous version backed up)'
-                    : 'Completion script updated successfully';
+                    ? COMPLETION_MESSAGES.fishUpdatedWithBackup
+                    : COMPLETION_MESSAGES.fishUpdated;
             }
             else {
-                message = 'Completion script installed successfully for Fish';
+                message = COMPLETION_MESSAGES.fishInstalled;
             }
             return {
                 success: true,
@@ -93,15 +94,15 @@ export class FishInstaller {
                 backupPath,
                 message,
                 instructions: [
-                    'Fish automatically loads completions from ~/.config/fish/completions/',
-                    'Completions are available immediately - no shell restart needed.',
+                    COMPLETION_MESSAGES.fishAutoLoadsDir,
+                    COMPLETION_MESSAGES.fishAvailableImmediately,
                 ],
             };
         }
         catch (error) {
             return {
                 success: false,
-                message: `Failed to install completion script: ${error instanceof Error ? error.message : String(error)}`,
+                message: COMPLETION_MESSAGES.fishFailedToInstall(error instanceof Error ? error.message : String(error)),
             };
         }
     }
@@ -122,20 +123,20 @@ export class FishInstaller {
             catch {
                 return {
                     success: false,
-                    message: 'Completion script is not installed',
+                    message: COMPLETION_MESSAGES.fishNotInstalled,
                 };
             }
             // Remove the completion script
             await fs.unlink(targetPath);
             return {
                 success: true,
-                message: 'Completion script uninstalled successfully',
+                message: COMPLETION_MESSAGES.fishUninstalled,
             };
         }
         catch (error) {
             return {
                 success: false,
-                message: `Failed to uninstall completion script: ${error instanceof Error ? error.message : String(error)}`,
+                message: COMPLETION_MESSAGES.fishFailedToUninstall(error instanceof Error ? error.message : String(error)),
             };
         }
     }

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

@@ -29,8 +29,7 @@ export class PowerShellInstaller {
         }
         // UTF-16 BE BOM: FE FF — not natively supported by Node
         if (buffer.length >= 2 && buffer[0] === 0xfe && buffer[1] === 0xff) {
-            throw new Error('File is encoded as UTF-16 BE which is not supported. ' +
-                'Please re-save as UTF-8 or UTF-16 LE, then retry.');
+            throw new Error(COMPLETION_MESSAGES.powershellUtf16BEUnsupported);
         }
         // UTF-8 BOM: EF BB BF
         if (buffer.length >= 3 && buffer[0] === 0xef && buffer[1] === 0xbb && buffer[2] === 0xbf) {
@@ -274,10 +273,10 @@ export class PowerShellInstaller {
                     return {
                         success: true,
                         installedPath: targetPath,
-                        message: 'Completion script is already installed (up to date)',
+                        message: COMPLETION_MESSAGES.powershellAlreadyInstalled,
                         instructions: [
-                            'The completion script is already installed and up to date.',
-                            'If completions are not working, try restarting PowerShell or run: . $PROFILE',
+                            COMPLETION_MESSAGES.powershellAlreadyInstalledDetail,
+                            COMPLETION_MESSAGES.powershellAlreadyInstalledHint,
                         ],
                     };
                 }
@@ -315,13 +314,13 @@ export class PowerShellInstaller {
             let message;
             if (isUpdate) {
                 message = backupPath
-                    ? 'Completion script updated successfully (previous version backed up)'
-                    : 'Completion script updated successfully';
+                    ? COMPLETION_MESSAGES.powershellUpdatedWithBackup
+                    : COMPLETION_MESSAGES.powershellUpdated;
             }
             else {
                 message = profileConfigured
-                    ? 'Completion script installed and PowerShell profile configured successfully'
-                    : 'Completion script installed successfully for PowerShell';
+                    ? COMPLETION_MESSAGES.powershellInstalledWithProfile
+                    : COMPLETION_MESSAGES.powershellInstalled;
             }
             return {
                 success: true,
@@ -335,7 +334,7 @@ export class PowerShellInstaller {
         catch (error) {
             return {
                 success: false,
-                message: `Failed to install completion script: ${error instanceof Error ? error.message : String(error)}`,
+                message: COMPLETION_MESSAGES.powershellFailedToInstall(error instanceof Error ? error.message : String(error)),
             };
         }
     }
@@ -348,16 +347,16 @@ export class PowerShellInstaller {
     generateInstructions(installedPath) {
         const profilePath = this.getProfilePath();
         return [
-            'Completion script installed successfully.',
+            COMPLETION_MESSAGES.powershellScriptInstalled,
             '',
-            `To enable completions, add the following to your PowerShell profile (${profilePath}):`,
+            COMPLETION_MESSAGES.powershellEnableCompletions(profilePath),
             '',
-            '  # Source BR-OpenSpec completions',
+            `  ${COMPLETION_MESSAGES.powershellSourceComment}`,
             `  if (Test-Path "${installedPath}") {`,
             `      . "${installedPath}"`,
             '  }',
             '',
-            'Then restart PowerShell or run: . $PROFILE',
+            COMPLETION_MESSAGES.powershellThenRestart,
         ];
     }
     /**
@@ -377,7 +376,7 @@ export class PowerShellInstaller {
             catch {
                 return {
                     success: false,
-                    message: 'Completion script is not installed',
+                    message: COMPLETION_MESSAGES.powershellNotInstalled,
                 };
             }
             // Remove the completion script
@@ -386,13 +385,13 @@ export class PowerShellInstaller {
             await this.removeProfileConfig();
             return {
                 success: true,
-                message: 'Completion script uninstalled successfully',
+                message: COMPLETION_MESSAGES.powershellUninstalled,
             };
         }
         catch (error) {
             return {
                 success: false,
-                message: `Failed to uninstall completion script: ${error instanceof Error ? error.message : String(error)}`,
+                message: COMPLETION_MESSAGES.powershellFailedToUninstall(error instanceof Error ? error.message : String(error)),
             };
         }
     }

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

@@ -392,7 +392,7 @@ export class ZshInstaller {
             if (!scriptRemoved && !zshrcWasPresent) {
                 return {
                     success: false,
-                    message: 'Completion script is not installed',
+                    message: COMPLETION_MESSAGES.zshNotInstalled,
                 };
             }
             const messages = [];

package/dist/core/parsers/change-parser.js

@@ -1,6 +1,7 @@
 import { MarkdownParser } from './markdown-parser.js';
 import path from 'path';
 import { promises as fs } from 'fs';
+import { CHANGE_PARSER_MESSAGES } from '../../messages/index.js';
 export class ChangeParser extends MarkdownParser {
     changeDir;
     constructor(content, changeDir) {
@@ -12,10 +13,10 @@ export class ChangeParser extends MarkdownParser {
         const why = this.findSection(sections, 'Why')?.content || '';
         const whatChanges = this.findSection(sections, 'What Changes')?.content || '';
         if (!why) {
-            throw new Error('Change must have a Why section');
+            throw new Error(CHANGE_PARSER_MESSAGES.mustHaveWhySection);
         }
         if (!whatChanges) {
-            throw new Error('Change must have a What Changes section');
+            throw new Error(CHANGE_PARSER_MESSAGES.mustHaveWhatChangesSection);
         }
         // Parse deltas from the What Changes section (simple format)
         const simpleDeltas = this.parseDeltas(whatChanges);
@@ -72,7 +73,7 @@ export class ChangeParser extends MarkdownParser {
                 deltas.push({
                     spec: specName,
                     operation: 'ADDED',
-                    description: `Add requirement: ${req.text}`,
+                    description: CHANGE_PARSER_MESSAGES.addRequirement(req.text),
                     // Provide both single and plural forms for compatibility
                     requirement: req,
                     requirements: [req],
@@ -87,7 +88,7 @@ export class ChangeParser extends MarkdownParser {
                 deltas.push({
                     spec: specName,
                     operation: 'MODIFIED',
-                    description: `Modify requirement: ${req.text}`,
+                    description: CHANGE_PARSER_MESSAGES.modifyRequirement(req.text),
                     requirement: req,
                     requirements: [req],
                 });
@@ -101,7 +102,7 @@ export class ChangeParser extends MarkdownParser {
                 deltas.push({
                     spec: specName,
                     operation: 'REMOVED',
-                    description: `Remove requirement: ${req.text}`,
+                    description: CHANGE_PARSER_MESSAGES.removeRequirement(req.text),
                     requirement: req,
                     requirements: [req],
                 });
@@ -115,7 +116,7 @@ export class ChangeParser extends MarkdownParser {
                 deltas.push({
                     spec: specName,
                     operation: 'RENAMED',
-                    description: `Rename requirement from "${rename.from}" to "${rename.to}"`,
+                    description: CHANGE_PARSER_MESSAGES.renameRequirement(rename.from, rename.to),
                     rename,
                 });
             });

package/dist/core/project-config.js

@@ -1,4 +1,4 @@
-import { PROJECT_CONFIG_MESSAGES } from '../messages/index.js';
+import { PROJECT_CONFIG_MESSAGES, PROJECT_CONFIG_SUGGEST_MESSAGES } from '../messages/index.js';
 import { existsSync, readFileSync } from 'fs';
 import path from 'path';
 import { parse as parseYaml } from 'yaml';
@@ -69,7 +69,7 @@ export function readProjectConfig(projectRoot) {
         const content = readFileSync(configPath, 'utf-8');
         const raw = parseYaml(content);
         if (!raw || typeof raw !== 'object') {
-            console.warn(`openspec/config.yaml is not a valid YAML object`);
+            console.warn(PROJECT_CONFIG_SUGGEST_MESSAGES.configNotValidYaml);
             return null;
         }
         const config = {};
@@ -136,7 +136,7 @@ export function readProjectConfig(projectRoot) {
         return Object.keys(config).length > 0 ? config : null;
     }
     catch (error) {
-        console.warn(`Failed to parse openspec/config.yaml:`, error);
+        console.warn(PROJECT_CONFIG_SUGGEST_MESSAGES.configFailedToParse, error);
         return null;
     }
 }
@@ -155,8 +155,7 @@ export function validateConfigRules(rules, validArtifactIds, schemaName) {
     for (const artifactId of Object.keys(rules)) {
         if (!validArtifactIds.has(artifactId)) {
             const validIds = Array.from(validArtifactIds).sort().join(', ');
-            warnings.push(`Unknown artifact ID in rules: "${artifactId}". ` +
-                `Valid IDs for schema "${schemaName}": ${validIds}`);
+            warnings.push(PROJECT_CONFIG_SUGGEST_MESSAGES.unknownArtifactId(artifactId, schemaName, validIds));
         }
     }
     return warnings;
@@ -199,26 +198,26 @@ export function suggestSchemas(invalidSchemaName, availableSchemas) {
         .slice(0, 3);
     const builtIn = availableSchemas.filter((s) => s.isBuiltIn).map((s) => s.name);
     const projectLocal = availableSchemas.filter((s) => !s.isBuiltIn).map((s) => s.name);
-    let message = `Schema '${invalidSchemaName}' not found in openspec/config.yaml\n\n`;
+    let message = PROJECT_CONFIG_SUGGEST_MESSAGES.schemaNotFound(invalidSchemaName);
     if (suggestions.length > 0) {
-        message += `Did you mean one of these?\n`;
+        message += PROJECT_CONFIG_SUGGEST_MESSAGES.didYouMean;
         suggestions.forEach((s) => {
-            const type = s.isBuiltIn ? 'built-in' : 'project-local';
+            const type = PROJECT_CONFIG_SUGGEST_MESSAGES.schemaType(s.isBuiltIn);
             message += `  - ${s.name} (${type})\n`;
         });
         message += '\n';
     }
-    message += `Available schemas:\n`;
+    message += PROJECT_CONFIG_SUGGEST_MESSAGES.availableSchemas;
     if (builtIn.length > 0) {
-        message += `  Built-in: ${builtIn.join(', ')}\n`;
+        message += PROJECT_CONFIG_SUGGEST_MESSAGES.builtInSchemas(builtIn.join(', '));
     }
     if (projectLocal.length > 0) {
-        message += `  Project-local: ${projectLocal.join(', ')}\n`;
+        message += PROJECT_CONFIG_SUGGEST_MESSAGES.projectLocalSchemas(projectLocal.join(', '));
     }
     else {
-        message += `  Project-local: (none found)\n`;
+        message += PROJECT_CONFIG_SUGGEST_MESSAGES.noProjectLocalSchemas;
     }
-    message += `\nFix: Edit openspec/config.yaml and change 'schema: ${invalidSchemaName}' to a valid schema name`;
+    message += PROJECT_CONFIG_SUGGEST_MESSAGES.fixSuggestion(invalidSchemaName);
     return message;
 }
 //# sourceMappingURL=project-config.js.map

package/dist/core/specs-apply.js

@@ -10,7 +10,7 @@ import chalk from 'chalk';
 import { extractRequirementsSection, parseDeltaSpec, normalizeRequirementName, } from './parsers/requirement-blocks.js';
 import { findMainSpecStructureIssues } from './parsers/spec-structure.js';
 import { Validator } from './validation/validator.js';
-import { ARCHIVE_MESSAGES } from '../messages/index.js';
+import { ARCHIVE_MESSAGES, SPECS_APPLY_MESSAGES } from '../messages/index.js';
 // -----------------------------------------------------------------------------
 // Public API
 // -----------------------------------------------------------------------------
@@ -69,7 +69,7 @@ export async function buildUpdatedSpec(update, changeName) {
     for (const add of plan.added) {
         const name = normalizeRequirementName(add.name);
         if (addedNames.has(name)) {
-            throw new Error(`${specName} validation failed - duplicate requirement in ADDED for header "### Requirement: ${add.name}"`);
+            throw new Error(SPECS_APPLY_MESSAGES.duplicateInSection(specName, 'ADDED', add.name));
         }
         addedNames.add(name);
     }
@@ -77,7 +77,7 @@ export async function buildUpdatedSpec(update, changeName) {
     for (const mod of plan.modified) {
         const name = normalizeRequirementName(mod.name);
         if (modifiedNames.has(name)) {
-            throw new Error(`${specName} validation failed - duplicate requirement in MODIFIED for header "### Requirement: ${mod.name}"`);
+            throw new Error(SPECS_APPLY_MESSAGES.duplicateInSection(specName, 'MODIFIED', mod.name));
         }
         modifiedNames.add(name);
     }
@@ -85,7 +85,7 @@ export async function buildUpdatedSpec(update, changeName) {
     for (const rem of plan.removed) {
         const name = normalizeRequirementName(rem);
         if (removedNamesSet.has(name)) {
-            throw new Error(`${specName} validation failed - duplicate requirement in REMOVED for header "### Requirement: ${rem}"`);
+            throw new Error(SPECS_APPLY_MESSAGES.duplicateInSection(specName, 'REMOVED', rem));
         }
         removedNamesSet.add(name);
     }
@@ -95,10 +95,10 @@ export async function buildUpdatedSpec(update, changeName) {
         const fromNorm = normalizeRequirementName(from);
         const toNorm = normalizeRequirementName(to);
         if (renamedFromSet.has(fromNorm)) {
-            throw new Error(`${specName} validation failed - duplicate FROM in RENAMED for header "### Requirement: ${from}"`);
+            throw new Error(SPECS_APPLY_MESSAGES.duplicateFromInRenamed(specName, from));
         }
         if (renamedToSet.has(toNorm)) {
-            throw new Error(`${specName} validation failed - duplicate TO in RENAMED for header "### Requirement: ${to}"`);
+            throw new Error(SPECS_APPLY_MESSAGES.duplicateToInRenamed(specName, to));
         }
         renamedFromSet.add(fromNorm);
         renamedToSet.add(toNorm);
@@ -120,21 +120,20 @@ export async function buildUpdatedSpec(update, changeName) {
         const fromNorm = normalizeRequirementName(from);
         const toNorm = normalizeRequirementName(to);
         if (modifiedNames.has(fromNorm)) {
-            throw new Error(`${specName} validation failed - when a rename exists, MODIFIED must reference the NEW header "### Requirement: ${to}"`);
+            throw new Error(SPECS_APPLY_MESSAGES.renamedModifiedMustReferenceNew(specName, to));
         }
         // Detect ADDED colliding with a RENAMED TO
         if (addedNames.has(toNorm)) {
-            throw new Error(`${specName} validation failed - RENAMED TO header collides with ADDED for "### Requirement: ${to}"`);
+            throw new Error(SPECS_APPLY_MESSAGES.renamedToCollidesWithAdded(specName, to));
         }
     }
     if (conflicts.length > 0) {
         const c = conflicts[0];
-        throw new Error(`${specName} validation failed - requirement present in multiple sections (${c.a} and ${c.b}) for header "### Requirement: ${c.name}"`);
+        throw new Error(SPECS_APPLY_MESSAGES.requirementInMultipleSections(specName, c.a, c.b, c.name));
     }
     const hasAnyDelta = plan.added.length + plan.modified.length + plan.removed.length + plan.renamed.length > 0;
     if (!hasAnyDelta) {
-        throw new Error(`Delta parsing found no operations for ${path.basename(path.dirname(update.source))}. ` +
-            `Provide ADDED/MODIFIED/REMOVED/RENAMED sections in change spec.`);
+        throw new Error(SPECS_APPLY_MESSAGES.noDeltaOperations(path.basename(path.dirname(update.source))));
     }
     // Load or create base target content
     let targetContent;
@@ -146,7 +145,7 @@ export async function buildUpdatedSpec(update, changeName) {
         // Target spec does not exist; MODIFIED and RENAMED are not allowed for new specs
         // REMOVED will be ignored with a warning since there's nothing to remove
         if (plan.modified.length > 0 || plan.renamed.length > 0) {
-            throw new Error(`${specName}: target spec does not exist; only ADDED requirements are allowed for new specs. MODIFIED and RENAMED operations require an existing spec.`);
+            throw new Error(SPECS_APPLY_MESSAGES.targetSpecNotExists(specName));
         }
         // Warn about REMOVED requirements being ignored for new specs
         if (plan.removed.length > 0) {
@@ -160,7 +159,7 @@ export async function buildUpdatedSpec(update, changeName) {
         const details = structureIssues
             .map(issue => `line ${issue.line}: ${issue.message}`)
             .join('\n');
-        throw new Error(`${specName}: target spec is structurally invalid and cannot be updated until fixed:\n${details}`);
+        throw new Error(SPECS_APPLY_MESSAGES.targetSpecStructurallyInvalid(specName, details));
     }
     // Extract requirements section and build name->block map
     const parts = extractRequirementsSection(targetContent);
@@ -174,10 +173,10 @@ export async function buildUpdatedSpec(update, changeName) {
         const from = normalizeRequirementName(r.from);
         const to = normalizeRequirementName(r.to);
         if (!nameToBlock.has(from)) {
-            throw new Error(`${specName} RENAMED failed for header "### Requirement: ${r.from}" - source not found`);
+            throw new Error(SPECS_APPLY_MESSAGES.renamedFailedSourceNotFound(specName, r.from));
         }
         if (nameToBlock.has(to)) {
-            throw new Error(`${specName} RENAMED failed for header "### Requirement: ${r.to}" - target already exists`);
+            throw new Error(SPECS_APPLY_MESSAGES.renamedFailedTargetExists(specName, r.to));
         }
         const block = nameToBlock.get(from);
         const newHeader = `### Requirement: ${to}`;
@@ -198,7 +197,7 @@ export async function buildUpdatedSpec(update, changeName) {
             // For new specs, REMOVED requirements are already warned about and ignored
             // For existing specs, missing requirements are an error
             if (!isNewSpec) {
-                throw new Error(`${specName} REMOVED failed for header "### Requirement: ${name}" - not found`);
+                throw new Error(SPECS_APPLY_MESSAGES.removedFailedNotFound(specName, name));
             }
             // Skip removal for new specs (already warned above)
             continue;
@@ -209,12 +208,12 @@ export async function buildUpdatedSpec(update, changeName) {
     for (const mod of plan.modified) {
         const key = normalizeRequirementName(mod.name);
         if (!nameToBlock.has(key)) {
-            throw new Error(`${specName} MODIFIED failed for header "### Requirement: ${mod.name}" - not found`);
+            throw new Error(SPECS_APPLY_MESSAGES.modifiedFailedNotFound(specName, mod.name));
         }
         // Replace block with provided raw (ensure header line matches key)
         const modHeaderMatch = mod.raw.split('\n')[0].match(/^###\s*Requirement:\s*(.+)\s*$/);
         if (!modHeaderMatch || normalizeRequirementName(modHeaderMatch[1]) !== key) {
-            throw new Error(`${specName} MODIFIED failed for header "### Requirement: ${mod.name}" - header mismatch in content`);
+            throw new Error(SPECS_APPLY_MESSAGES.modifiedFailedHeaderMismatch(specName, mod.name));
         }
         nameToBlock.set(key, mod);
     }
@@ -222,7 +221,7 @@ export async function buildUpdatedSpec(update, changeName) {
     for (const add of plan.added) {
         const key = normalizeRequirementName(add.name);
         if (nameToBlock.has(key)) {
-            throw new Error(`${specName} ADDED failed for header "### Requirement: ${add.name}" - already exists`);
+            throw new Error(SPECS_APPLY_MESSAGES.addedFailedAlreadyExists(specName, add.name));
         }
         nameToBlock.set(key, add);
     }
@@ -272,22 +271,22 @@ export async function writeUpdatedSpec(update, rebuilt, counts) {
     await fs.mkdir(targetDir, { recursive: true });
     await fs.writeFile(update.target, rebuilt);
     const specName = path.basename(path.dirname(update.target));
-    console.log(`Applying changes to openspec/specs/${specName}/spec.md:`);
+    console.log(SPECS_APPLY_MESSAGES.applyingChangesTo(specName));
     if (counts.added)
-        console.log(`  + ${counts.added} added`);
+        console.log(SPECS_APPLY_MESSAGES.countAdded(counts.added));
     if (counts.modified)
-        console.log(`  ~ ${counts.modified} modified`);
+        console.log(SPECS_APPLY_MESSAGES.countModified(counts.modified));
     if (counts.removed)
-        console.log(`  - ${counts.removed} removed`);
+        console.log(SPECS_APPLY_MESSAGES.countRemoved(counts.removed));
     if (counts.renamed)
-        console.log(`  → ${counts.renamed} renamed`);
+        console.log(SPECS_APPLY_MESSAGES.countRenamed(counts.renamed));
 }
 /**
  * Build a skeleton spec for new capabilities.
  */
 export function buildSpecSkeleton(specFolderName, changeName) {
     const titleBase = specFolderName;
-    return `# ${titleBase} Specification\n\n## Purpose\nTBD - created by archiving change ${changeName}. Update Purpose after archive.\n\n## Requirements\n`;
+    return `# ${titleBase} Specification\n\n## Purpose\n${SPECS_APPLY_MESSAGES.skeletonPurpose(changeName)}\n\n## Requirements\n`;
 }
 /**
  * Apply all delta specs from a change to main specs.
@@ -304,11 +303,11 @@ export async function applySpecs(projectRoot, changeName, options = {}) {
     try {
         const stat = await fs.stat(changeDir);
         if (!stat.isDirectory()) {
-            throw new Error(`Change '${changeName}' not found.`);
+            throw new Error(SPECS_APPLY_MESSAGES.changeNotFound(changeName));
         }
     }
     catch {
-        throw new Error(`Change '${changeName}' not found.`);
+        throw new Error(SPECS_APPLY_MESSAGES.changeNotFound(changeName));
     }
     // Find specs to update
     const specUpdates = await findSpecUpdates(changeDir, mainSpecsDir);
@@ -337,7 +336,7 @@ export async function applySpecs(projectRoot, changeName, options = {}) {
                     .filter((i) => i.level === 'ERROR')
                     .map((i) => `  ✗ ${i.message}`)
                     .join('\n');
-                throw new Error(`Validation errors in rebuilt spec for ${specName}:\n${errors}`);
+                throw new Error(SPECS_APPLY_MESSAGES.validationErrorsInRebuiltSpec(specName, errors));
             }
         }
     }
@@ -352,27 +351,27 @@ export async function applySpecs(projectRoot, changeName, options = {}) {
             await fs.mkdir(targetDir, { recursive: true });
             await fs.writeFile(p.update.target, p.rebuilt);
             if (!options.silent) {
-                console.log(`Applying changes to openspec/specs/${capability}/spec.md:`);
+                console.log(SPECS_APPLY_MESSAGES.applyingChangesTo(capability));
                 if (p.counts.added)
-                    console.log(`  + ${p.counts.added} added`);
+                    console.log(SPECS_APPLY_MESSAGES.countAdded(p.counts.added));
                 if (p.counts.modified)
-                    console.log(`  ~ ${p.counts.modified} modified`);
+                    console.log(SPECS_APPLY_MESSAGES.countModified(p.counts.modified));
                 if (p.counts.removed)
-                    console.log(`  - ${p.counts.removed} removed`);
+                    console.log(SPECS_APPLY_MESSAGES.countRemoved(p.counts.removed));
                 if (p.counts.renamed)
-                    console.log(`  → ${p.counts.renamed} renamed`);
+                    console.log(SPECS_APPLY_MESSAGES.countRenamed(p.counts.renamed));
             }
         }
         else if (!options.silent) {
-            console.log(`Would apply changes to openspec/specs/${capability}/spec.md:`);
+            console.log(SPECS_APPLY_MESSAGES.wouldApplyChangesTo(capability));
             if (p.counts.added)
-                console.log(`  + ${p.counts.added} added`);
+                console.log(SPECS_APPLY_MESSAGES.countAdded(p.counts.added));
             if (p.counts.modified)
-                console.log(`  ~ ${p.counts.modified} modified`);
+                console.log(SPECS_APPLY_MESSAGES.countModified(p.counts.modified));
             if (p.counts.removed)
-                console.log(`  - ${p.counts.removed} removed`);
+                console.log(SPECS_APPLY_MESSAGES.countRemoved(p.counts.removed));
             if (p.counts.renamed)
-                console.log(`  → ${p.counts.renamed} renamed`);
+                console.log(SPECS_APPLY_MESSAGES.countRenamed(p.counts.renamed));
         }
         capabilities.push({
             capability,

package/dist/core/tools-manager.js

@@ -4,7 +4,7 @@
  * Encapsulates adding and removing IDE/Code Agent OpenSpec configuration files.
  * Shared by `openspec init` (via InitCommand) and `openspec tools`.
  */
-import { TOOLS_MESSAGES } from '../messages/index.js';
+import { TOOLS_MESSAGES, TOOLS_MANAGER_MESSAGES } from '../messages/index.js';
 import path from 'path';
 import * as fs from 'fs';
 import { createRequire } from 'module';
@@ -100,7 +100,7 @@ export async function removeOpenSpecCommandFiles(projectPath, toolId) {
  */
 export async function addTool(projectPath, tool) {
     if (!tool.skillsDir) {
-        throw new Error(`Tool '${tool.value}' does not support skill generation.`);
+        throw new Error(TOOLS_MANAGER_MESSAGES.toolDoesNotSupportSkills(tool.value));
     }
     const globalConfig = getGlobalConfig();
     const profile = globalConfig.profile ?? 'core';

package/dist/messages/index.d.ts

@@ -607,6 +607,35 @@ export declare const COMPLETION_MESSAGES: {
     warningCouldNotRemoveLegacy: (path: string, err: string) => string;
     powershellCompletionHeader: string;
     powershellCompletionNote: string;
+    fishAlreadyInstalled: string;
+    fishAlreadyInstalledDetail: string;
+    fishAutoLoadsHint: string;
+    fishUpdatedWithBackup: string;
+    fishUpdated: string;
+    fishInstalled: string;
+    fishAutoLoadsDir: string;
+    fishAvailableImmediately: string;
+    fishFailedToInstall: (error: string) => string;
+    fishNotInstalled: string;
+    fishUninstalled: string;
+    fishFailedToUninstall: (error: string) => string;
+    powershellUtf16BEUnsupported: string;
+    powershellAlreadyInstalled: string;
+    powershellAlreadyInstalledDetail: string;
+    powershellAlreadyInstalledHint: string;
+    powershellUpdatedWithBackup: string;
+    powershellUpdated: string;
+    powershellInstalledWithProfile: string;
+    powershellInstalled: string;
+    powershellFailedToInstall: (error: string) => string;
+    powershellScriptInstalled: string;
+    powershellEnableCompletions: (profilePath: string) => string;
+    powershellSourceComment: string;
+    powershellThenRestart: string;
+    powershellNotInstalled: string;
+    powershellUninstalled: string;
+    powershellFailedToUninstall: (error: string) => string;
+    zshNotInstalled: string;
 };
 export declare const FEEDBACK_MESSAGES: {
     submitFeedback: string;
@@ -864,4 +893,86 @@ export declare const VERIFY_CHANGE_TEMPLATE_MESSAGES: {
 export declare const TELEMETRY_MESSAGES: {
     firstRunNotice: string;
 };
+export declare const CHANGE_PARSER_MESSAGES: {
+    mustHaveWhySection: string;
+    mustHaveWhatChangesSection: string;
+    addRequirement: (text: string) => string;
+    modifyRequirement: (text: string) => string;
+    removeRequirement: (text: string) => string;
+    renameRequirement: (from: string, to: string) => string;
+};
+export declare const SPECS_APPLY_MESSAGES: {
+    duplicateInSection: (specName: string, section: string, reqName: string) => string;
+    duplicateFromInRenamed: (specName: string, reqName: string) => string;
+    duplicateToInRenamed: (specName: string, reqName: string) => string;
+    renamedModifiedMustReferenceNew: (specName: string, toName: string) => string;
+    renamedToCollidesWithAdded: (specName: string, toName: string) => string;
+    requirementInMultipleSections: (specName: string, sectionA: string, sectionB: string, reqName: string) => string;
+    noDeltaOperations: (capability: string) => string;
+    targetSpecNotExists: (specName: string) => string;
+    targetSpecStructurallyInvalid: (specName: string, details: string) => string;
+    renamedFailedSourceNotFound: (specName: string, reqName: string) => string;
+    renamedFailedTargetExists: (specName: string, reqName: string) => string;
+    removedFailedNotFound: (specName: string, reqName: string) => string;
+    modifiedFailedNotFound: (specName: string, reqName: string) => string;
+    modifiedFailedHeaderMismatch: (specName: string, reqName: string) => string;
+    addedFailedAlreadyExists: (specName: string, reqName: string) => string;
+    applyingChangesTo: (specPath: string) => string;
+    wouldApplyChangesTo: (specPath: string) => string;
+    countAdded: (n: number) => string;
+    countModified: (n: number) => string;
+    countRemoved: (n: number) => string;
+    countRenamed: (n: number) => string;
+    skeletonPurpose: (changeName: string) => string;
+    changeNotFound: (changeName: string) => string;
+    validationErrorsInRebuiltSpec: (specName: string, errors: string) => string;
+};
+export declare const PROJECT_CONFIG_SUGGEST_MESSAGES: {
+    configNotValidYaml: string;
+    configFailedToParse: string;
+    unknownArtifactId: (artifactId: string, schemaName: string, validIds: string) => string;
+    schemaNotFound: (schemaName: string) => string;
+    didYouMean: string;
+    schemaType: (isBuiltIn: boolean) => "nativo" | "local do projeto";
+    availableSchemas: string;
+    builtInSchemas: (schemas: string) => string;
+    projectLocalSchemas: (schemas: string) => string;
+    noProjectLocalSchemas: string;
+    fixSuggestion: (invalidName: string) => string;
+};
+export declare const TOOLS_MANAGER_MESSAGES: {
+    toolDoesNotSupportSkills: (toolValue: string) => string;
+};
+export declare const ARTIFACT_GRAPH_MESSAGES: {
+    invalidSchema: (errors: string) => string;
+    duplicateArtifactId: (id: string) => string;
+    invalidDependencyReference: (artifactId: string, ref: string) => string;
+    cyclicDependency: (cycle: string) => string;
+    templateNotFound: (path: string) => string;
+    failedToReadTemplate: (error: string) => string;
+    artifactNotFound: (artifactId: string, schemaName: string) => string;
+};
+export declare const CHANGE_METADATA_MESSAGES: {
+    failedToWriteMetadata: (error: string) => string;
+    failedToReadMetadata: (error: string) => string;
+    invalidMetadata: (error: string) => string;
+    invalidYaml: (error: string) => string;
+    unknownSchema: (schema: string, available: string) => string;
+};
+export declare const CHANGE_UTILS_MESSAGES: {
+    changeAlreadyExists: (name: string, dir: string) => string;
+    nameEmpty: string;
+    nameMustBeLowercase: string;
+    nameNoSpaces: string;
+    nameNoUnderscores: string;
+    nameNoStartHyphen: string;
+    nameNoEndHyphen: string;
+    nameNoConsecutiveHyphens: string;
+    nameOnlyAllowedChars: string;
+    nameMustStartWithLetter: string;
+    nameKebabCase: string;
+};
+export declare const COMPLETIONS_FACTORY_MESSAGES: {
+    unsupportedShell: (shell: string) => string;
+};
 //# sourceMappingURL=index.d.ts.map

package/dist/messages/index.js

@@ -669,6 +669,38 @@ export const COMPLETION_MESSAGES = {
     warningCouldNotRemoveLegacy: (path, err) => `Aviso: Não foi possível remover arquivo legado ${path}: ${err}`,
     powershellCompletionHeader: '# Script de autocompletar PowerShell para a CLI do BR-OpenSpec',
     powershellCompletionNote: '# Gerado automaticamente - não edite manualmente',
+    // Fish installer messages
+    fishAlreadyInstalled: 'Script de autocomplete já está instalado (atualizado)',
+    fishAlreadyInstalledDetail: 'O script de autocomplete já está instalado e atualizado.',
+    fishAutoLoadsHint: 'O Fish carrega automaticamente os scripts de autocomplete - devem estar disponíveis imediatamente.',
+    fishUpdatedWithBackup: 'Script de autocomplete atualizado com sucesso (versão anterior salva em backup)',
+    fishUpdated: 'Script de autocomplete atualizado com sucesso',
+    fishInstalled: 'Script de autocomplete instalado com sucesso para Fish',
+    fishAutoLoadsDir: 'O Fish carrega automaticamente os scripts de autocomplete de ~/.config/fish/completions/',
+    fishAvailableImmediately: 'Os autocompletes estão disponíveis imediatamente - sem necessidade de reiniciar o shell.',
+    fishFailedToInstall: (error) => `Falha ao instalar script de autocomplete: ${error}`,
+    fishNotInstalled: 'Script de autocomplete não está instalado',
+    fishUninstalled: 'Script de autocomplete desinstalado com sucesso',
+    fishFailedToUninstall: (error) => `Falha ao desinstalar script de autocomplete: ${error}`,
+    // PowerShell installer messages
+    powershellUtf16BEUnsupported: 'Arquivo codificado em UTF-16 BE não é suportado. Salve novamente como UTF-8 ou UTF-16 LE e tente novamente.',
+    powershellAlreadyInstalled: 'Script de autocomplete já está instalado (atualizado)',
+    powershellAlreadyInstalledDetail: 'O script de autocomplete já está instalado e atualizado.',
+    powershellAlreadyInstalledHint: 'Se o autocomplete não estiver funcionando, tente reiniciar o PowerShell ou execute: . $PROFILE',
+    powershellUpdatedWithBackup: 'Script de autocomplete atualizado com sucesso (versão anterior salva em backup)',
+    powershellUpdated: 'Script de autocomplete atualizado com sucesso',
+    powershellInstalledWithProfile: 'Script de autocomplete instalado e perfil do PowerShell configurado com sucesso',
+    powershellInstalled: 'Script de autocomplete instalado com sucesso para PowerShell',
+    powershellFailedToInstall: (error) => `Falha ao instalar script de autocomplete: ${error}`,
+    powershellScriptInstalled: 'Script de autocomplete instalado com sucesso.',
+    powershellEnableCompletions: (profilePath) => `Para ativar o autocomplete, adicione o seguinte ao seu perfil PowerShell (${profilePath}):`,
+    powershellSourceComment: '# Carrega os autocompletes do BR-OpenSpec',
+    powershellThenRestart: 'Depois reinicie o PowerShell ou execute: . $PROFILE',
+    powershellNotInstalled: 'Script de autocomplete não está instalado',
+    powershellUninstalled: 'Script de autocomplete desinstalado com sucesso',
+    powershellFailedToUninstall: (error) => `Falha ao desinstalar script de autocomplete: ${error}`,
+    // Zsh installer (missing)
+    zshNotInstalled: 'Script de autocomplete não está instalado',
 };
 // ═══════════════════════════════════════════════════════════
 // Comandos — Feedback (src/commands/feedback.ts)
@@ -1957,4 +1989,110 @@ Use markdown claro com:
 export const TELEMETRY_MESSAGES = {
     firstRunNotice: 'Aviso: o BR-OpenSpec coleta estatísticas de uso anônimas. Para optar por não participar, defina OPENSPEC_TELEMETRY=0',
 };
+// ═══════════════════════════════════════════════════════════
+// Parser — Change Parser (src/core/parsers/change-parser.ts)
+// ═══════════════════════════════════════════════════════════
+export const CHANGE_PARSER_MESSAGES = {
+    mustHaveWhySection: 'A alteração deve ter uma seção Why',
+    mustHaveWhatChangesSection: 'A alteração deve ter uma seção What Changes',
+    addRequirement: (text) => `Adicionar requisito: ${text}`,
+    modifyRequirement: (text) => `Modificar requisito: ${text}`,
+    removeRequirement: (text) => `Remover requisito: ${text}`,
+    renameRequirement: (from, to) => `Renomear requisito de "${from}" para "${to}"`,
+};
+// ═══════════════════════════════════════════════════════════
+// Core — Specs Apply (src/core/specs-apply.ts)
+// ═══════════════════════════════════════════════════════════
+export const SPECS_APPLY_MESSAGES = {
+    duplicateInSection: (specName, section, reqName) => `${specName} validação falhou - requisito duplicado em ${section} para cabeçalho "### Requirement: ${reqName}"`,
+    duplicateFromInRenamed: (specName, reqName) => `${specName} validação falhou - FROM duplicado em RENAMED para cabeçalho "### Requirement: ${reqName}"`,
+    duplicateToInRenamed: (specName, reqName) => `${specName} validação falhou - TO duplicado em RENAMED para cabeçalho "### Requirement: ${reqName}"`,
+    renamedModifiedMustReferenceNew: (specName, toName) => `${specName} validação falhou - quando existe um rename, MODIFIED deve referenciar o NOVO cabeçalho "### Requirement: ${toName}"`,
+    renamedToCollidesWithAdded: (specName, toName) => `${specName} validação falhou - cabeçalho RENAMED TO colide com ADDED para "### Requirement: ${toName}"`,
+    requirementInMultipleSections: (specName, sectionA, sectionB, reqName) => `${specName} validação falhou - requisito presente em múltiplas seções (${sectionA} e ${sectionB}) para cabeçalho "### Requirement: ${reqName}"`,
+    noDeltaOperations: (capability) => `Análise de delta não encontrou operações para ${capability}. Forneça seções ADDED/MODIFIED/REMOVED/RENAMED no spec da change.`,
+    targetSpecNotExists: (specName) => `${specName}: spec alvo não existe; somente requisitos ADDED são permitidos para specs novos. Operações MODIFIED e RENAMED requerem um spec existente.`,
+    targetSpecStructurallyInvalid: (specName, details) => `${specName}: spec alvo é estruturalmente inválido e não pode ser atualizado até ser corrigido:\n${details}`,
+    renamedFailedSourceNotFound: (specName, reqName) => `${specName} RENAMED falhou para cabeçalho "### Requirement: ${reqName}" - origem não encontrada`,
+    renamedFailedTargetExists: (specName, reqName) => `${specName} RENAMED falhou para cabeçalho "### Requirement: ${reqName}" - destino já existe`,
+    removedFailedNotFound: (specName, reqName) => `${specName} REMOVED falhou para cabeçalho "### Requirement: ${reqName}" - não encontrado`,
+    modifiedFailedNotFound: (specName, reqName) => `${specName} MODIFIED falhou para cabeçalho "### Requirement: ${reqName}" - não encontrado`,
+    modifiedFailedHeaderMismatch: (specName, reqName) => `${specName} MODIFIED falhou para cabeçalho "### Requirement: ${reqName}" - incompatibilidade de cabeçalho no conteúdo`,
+    addedFailedAlreadyExists: (specName, reqName) => `${specName} ADDED falhou para cabeçalho "### Requirement: ${reqName}" - já existe`,
+    applyingChangesTo: (specPath) => `Aplicando alterações em openspec/specs/${specPath}/spec.md:`,
+    wouldApplyChangesTo: (specPath) => `Aplicaria alterações em openspec/specs/${specPath}/spec.md:`,
+    countAdded: (n) => `  + ${n} adicionado(s)`,
+    countModified: (n) => `  ~ ${n} modificado(s)`,
+    countRemoved: (n) => `  - ${n} removido(s)`,
+    countRenamed: (n) => `  → ${n} renomeado(s)`,
+    skeletonPurpose: (changeName) => `A definir - criado ao arquivar alteração ${changeName}. Atualize o Purpose após o arquivamento.`,
+    changeNotFound: (changeName) => `Alteração '${changeName}' não encontrada.`,
+    validationErrorsInRebuiltSpec: (specName, errors) => `Erros de validação na especificação reconstruída para ${specName}:\n${errors}`,
+};
+// ═══════════════════════════════════════════════════════════
+// Core — Project Config (src/core/project-config.ts)
+// ═══════════════════════════════════════════════════════════
+export const PROJECT_CONFIG_SUGGEST_MESSAGES = {
+    configNotValidYaml: 'openspec/config.yaml não é um objeto YAML válido',
+    configFailedToParse: 'Falha ao analisar openspec/config.yaml:',
+    unknownArtifactId: (artifactId, schemaName, validIds) => `ID de artefato desconhecido nas regras: "${artifactId}". IDs válidos para o schema "${schemaName}": ${validIds}`,
+    schemaNotFound: (schemaName) => `Schema '${schemaName}' não encontrado em openspec/config.yaml\n\n`,
+    didYouMean: 'Você quis dizer algum destes?\n',
+    schemaType: (isBuiltIn) => isBuiltIn ? 'nativo' : 'local do projeto',
+    availableSchemas: 'Schemas disponíveis:\n',
+    builtInSchemas: (schemas) => `  Nativos: ${schemas}\n`,
+    projectLocalSchemas: (schemas) => `  Locais do projeto: ${schemas}\n`,
+    noProjectLocalSchemas: '  Locais do projeto: (nenhum encontrado)\n',
+    fixSuggestion: (invalidName) => `\nCorreção: Edite openspec/config.yaml e altere 'schema: ${invalidName}' para um nome de schema válido`,
+};
+// ═══════════════════════════════════════════════════════════
+// Core — Tools Manager (src/core/tools-manager.ts)
+// ═══════════════════════════════════════════════════════════
+export const TOOLS_MANAGER_MESSAGES = {
+    toolDoesNotSupportSkills: (toolValue) => `A ferramenta '${toolValue}' não suporta geração de skills.`,
+};
+// ═══════════════════════════════════════════════════════════
+// Core — Artifact Graph (src/core/artifact-graph/)
+// ═══════════════════════════════════════════════════════════
+export const ARTIFACT_GRAPH_MESSAGES = {
+    invalidSchema: (errors) => `Schema inválido: ${errors}`,
+    duplicateArtifactId: (id) => `ID de artefato duplicado: ${id}`,
+    invalidDependencyReference: (artifactId, ref) => `Referência de dependência inválida no artefato '${artifactId}': '${ref}' não existe`,
+    cyclicDependency: (cycle) => `Dependência cíclica detectada: ${cycle}`,
+    templateNotFound: (path) => `Template não encontrado: ${path}`,
+    failedToReadTemplate: (error) => `Falha ao ler template: ${error}`,
+    artifactNotFound: (artifactId, schemaName) => `Artefato '${artifactId}' não encontrado no schema '${schemaName}'`,
+};
+// ═══════════════════════════════════════════════════════════
+// Utils — Change Metadata (src/utils/change-metadata.ts)
+// ═══════════════════════════════════════════════════════════
+export const CHANGE_METADATA_MESSAGES = {
+    failedToWriteMetadata: (error) => `Falha ao escrever metadados: ${error}`,
+    failedToReadMetadata: (error) => `Falha ao ler metadados: ${error}`,
+    invalidMetadata: (error) => `Metadados inválidos: ${error}`,
+    invalidYaml: (error) => `YAML inválido no arquivo de metadados: ${error}`,
+    unknownSchema: (schema, available) => `Schema desconhecido '${schema}'. Disponíveis: ${available}`,
+};
+// ═══════════════════════════════════════════════════════════
+// Utils — Change Utils (src/utils/change-utils.ts)
+// ═══════════════════════════════════════════════════════════
+export const CHANGE_UTILS_MESSAGES = {
+    changeAlreadyExists: (name, dir) => `A alteração '${name}' já existe em ${dir}`,
+    nameEmpty: 'O nome da alteração não pode estar vazio',
+    nameMustBeLowercase: 'O nome da alteração deve ser minúsculo (use kebab-case)',
+    nameNoSpaces: 'O nome da alteração não pode conter espaços (use hífens)',
+    nameNoUnderscores: 'O nome da alteração não pode conter underscores (use hífens)',
+    nameNoStartHyphen: 'O nome da alteração não pode começar com hífen',
+    nameNoEndHyphen: 'O nome da alteração não pode terminar com hífen',
+    nameNoConsecutiveHyphens: 'O nome da alteração não pode conter hífens consecutivos',
+    nameOnlyAllowedChars: 'O nome da alteração pode conter apenas letras minúsculas, números e hífens',
+    nameMustStartWithLetter: 'O nome da alteração deve começar com uma letra',
+    nameKebabCase: 'O nome da alteração deve seguir a convenção kebab-case (ex: add-auth, refactor-db)',
+};
+// ═══════════════════════════════════════════════════════════
+// Core — Completions Factory (src/core/completions/factory.ts)
+// ═══════════════════════════════════════════════════════════
+export const COMPLETIONS_FACTORY_MESSAGES = {
+    unsupportedShell: (shell) => `Shell não suportado: ${shell}`,
+};
 //# sourceMappingURL=index.js.map

package/dist/utils/change-metadata.js

@@ -4,6 +4,7 @@ import * as yaml from 'yaml';
 import { ChangeMetadataSchema } from '../core/artifact-graph/types.js';
 import { listSchemas } from '../core/artifact-graph/resolver.js';
 import { readProjectConfig } from '../core/project-config.js';
+import { CHANGE_METADATA_MESSAGES } from '../messages/index.js';
 const METADATA_FILENAME = '.openspec.yaml';
 /**
  * Error thrown when change metadata validation fails.
@@ -29,7 +30,7 @@ export class ChangeMetadataError extends Error {
 export function validateSchemaName(schemaName, projectRoot) {
     const availableSchemas = listSchemas(projectRoot);
     if (!availableSchemas.includes(schemaName)) {
-        throw new Error(`Unknown schema '${schemaName}'. Available: ${availableSchemas.join(', ')}`);
+        throw new Error(CHANGE_METADATA_MESSAGES.unknownSchema(schemaName, availableSchemas.join(', ')));
     }
     return schemaName;
 }
@@ -48,7 +49,7 @@ export function writeChangeMetadata(changeDir, metadata, projectRoot) {
     // Validate with Zod
     const parseResult = ChangeMetadataSchema.safeParse(metadata);
     if (!parseResult.success) {
-        throw new ChangeMetadataError(`Invalid metadata: ${parseResult.error.message}`, metaPath);
+        throw new ChangeMetadataError(CHANGE_METADATA_MESSAGES.invalidMetadata(parseResult.error.message), metaPath);
     }
     // Write YAML file
     const content = yaml.stringify(parseResult.data);
@@ -57,7 +58,7 @@ export function writeChangeMetadata(changeDir, metadata, projectRoot) {
     }
     catch (err) {
         const ioError = err instanceof Error ? err : new Error(String(err));
-        throw new ChangeMetadataError(`Failed to write metadata: ${ioError.message}`, metaPath, ioError);
+        throw new ChangeMetadataError(CHANGE_METADATA_MESSAGES.failedToWriteMetadata(ioError.message), metaPath, ioError);
     }
 }
 /**
@@ -79,7 +80,7 @@ export function readChangeMetadata(changeDir, projectRoot) {
     }
     catch (err) {
         const ioError = err instanceof Error ? err : new Error(String(err));
-        throw new ChangeMetadataError(`Failed to read metadata: ${ioError.message}`, metaPath, ioError);
+        throw new ChangeMetadataError(CHANGE_METADATA_MESSAGES.failedToReadMetadata(ioError.message), metaPath, ioError);
     }
     let parsed;
     try {
@@ -87,17 +88,17 @@ export function readChangeMetadata(changeDir, projectRoot) {
     }
     catch (err) {
         const parseError = err instanceof Error ? err : new Error(String(err));
-        throw new ChangeMetadataError(`Invalid YAML in metadata file: ${parseError.message}`, metaPath, parseError);
+        throw new ChangeMetadataError(CHANGE_METADATA_MESSAGES.invalidYaml(parseError.message), metaPath, parseError);
     }
     // Validate with Zod
     const parseResult = ChangeMetadataSchema.safeParse(parsed);
     if (!parseResult.success) {
-        throw new ChangeMetadataError(`Invalid metadata: ${parseResult.error.message}`, metaPath);
+        throw new ChangeMetadataError(CHANGE_METADATA_MESSAGES.invalidMetadata(parseResult.error.message), metaPath);
     }
     // Validate that the schema exists
     const availableSchemas = listSchemas(projectRoot);
     if (!availableSchemas.includes(parseResult.data.schema)) {
-        throw new ChangeMetadataError(`Unknown schema '${parseResult.data.schema}'. Available: ${availableSchemas.join(', ')}`, metaPath);
+        throw new ChangeMetadataError(CHANGE_METADATA_MESSAGES.unknownSchema(parseResult.data.schema, availableSchemas.join(', ')), metaPath);
     }
     return parseResult.data;
 }

package/dist/utils/change-utils.js

@@ -2,6 +2,7 @@ import path from 'path';
 import { FileSystemUtils } from './file-system.js';
 import { writeChangeMetadata, validateSchemaName } from './change-metadata.js';
 import { readProjectConfig } from '../core/project-config.js';
+import { CHANGE_UTILS_MESSAGES } from '../messages/index.js';
 const DEFAULT_SCHEMA = 'spec-driven';
 /**
  * Validates that a change name follows kebab-case conventions.
@@ -24,35 +25,35 @@ export function validateChangeName(name) {
     // optionally followed by hyphen + lowercase letters/numbers (repeatable)
     const kebabCasePattern = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
     if (!name) {
-        return { valid: false, error: 'Change name cannot be empty' };
+        return { valid: false, error: CHANGE_UTILS_MESSAGES.nameEmpty };
     }
     if (!kebabCasePattern.test(name)) {
         // Provide specific error messages for common mistakes
         if (/[A-Z]/.test(name)) {
-            return { valid: false, error: 'Change name must be lowercase (use kebab-case)' };
+            return { valid: false, error: CHANGE_UTILS_MESSAGES.nameMustBeLowercase };
         }
         if (/\s/.test(name)) {
-            return { valid: false, error: 'Change name cannot contain spaces (use hyphens instead)' };
+            return { valid: false, error: CHANGE_UTILS_MESSAGES.nameNoSpaces };
         }
         if (/_/.test(name)) {
-            return { valid: false, error: 'Change name cannot contain underscores (use hyphens instead)' };
+            return { valid: false, error: CHANGE_UTILS_MESSAGES.nameNoUnderscores };
         }
         if (name.startsWith('-')) {
-            return { valid: false, error: 'Change name cannot start with a hyphen' };
+            return { valid: false, error: CHANGE_UTILS_MESSAGES.nameNoStartHyphen };
         }
         if (name.endsWith('-')) {
-            return { valid: false, error: 'Change name cannot end with a hyphen' };
+            return { valid: false, error: CHANGE_UTILS_MESSAGES.nameNoEndHyphen };
         }
         if (/--/.test(name)) {
-            return { valid: false, error: 'Change name cannot contain consecutive hyphens' };
+            return { valid: false, error: CHANGE_UTILS_MESSAGES.nameNoConsecutiveHyphens };
         }
         if (/[^a-z0-9-]/.test(name)) {
-            return { valid: false, error: 'Change name can only contain lowercase letters, numbers, and hyphens' };
+            return { valid: false, error: CHANGE_UTILS_MESSAGES.nameOnlyAllowedChars };
         }
         if (/^[0-9]/.test(name)) {
-            return { valid: false, error: 'Change name must start with a letter' };
+            return { valid: false, error: CHANGE_UTILS_MESSAGES.nameMustStartWithLetter };
         }
-        return { valid: false, error: 'Change name must follow kebab-case convention (e.g., add-auth, refactor-db)' };
+        return { valid: false, error: CHANGE_UTILS_MESSAGES.nameKebabCase };
     }
     return { valid: true };
 }
@@ -106,7 +107,7 @@ export async function createChange(projectRoot, name, options = {}) {
     const changeDir = path.join(projectRoot, 'openspec', 'changes', name);
     // Check if change already exists
     if (await FileSystemUtils.directoryExists(changeDir)) {
-        throw new Error(`Change '${name}' already exists at ${changeDir}`);
+        throw new Error(CHANGE_UTILS_MESSAGES.changeAlreadyExists(name, changeDir));
     }
     // Create the directory (including parent directories if needed)
     await FileSystemUtils.createDirectory(changeDir);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dynamicworks/br-openspec",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "description": "AI-native system for spec-driven development",
   "keywords": [
     "openspec",