@lwelliott/cortex-cli 1.0.3

package/dist/utils/errors.js

@@ -0,0 +1,1447 @@
+"use strict";
+// Typed error classes for cortex-cli
+// Error code prefix convention per approved SS specifications:
+//   ERR-DB-*    — Database layer errors (FS-SS-001-0001)
+//   ERR-CONN-*  — Connection errors (FS-SS-001-0003)
+//   ERR-MIG-*       — Database-level migration errors (FS-SS-001-0002)
+//   ERR-SCHEMA-*    — Schema validation errors (SAD-0012)
+//   ERR-MIGRATION-* — Schema migration orchestration errors (SAD-0012, MOD-022/022a-d)
+//   ERR-LOCK-*      — Lock/concurrency errors (FS-SS-003-0007)
+//   ERR-PROJ-*  — Project management errors (FS-SS-002-0001..0008)
+//   ERR-SPRINT-* — Sprint lifecycle errors (MOD-004)
+//   ERR-TASK-*   — Task/kanban lifecycle errors (MOD-005)
+//   ERR-SPAWN-*  — Spawn validation errors (MOD-006)
+//   ERR-CLI-*    — CLI routing/format errors (MOD-007)
+//   ERR-REG-*   — Registry errors (FS-SS-002-0010)
+//   ERR-AUDIT-* — Audit command errors (MOD-023)
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StageLockedError = exports.StageInvalidError = exports.StageBackwardError = exports.StageNoProgressError = exports.TaskBadStatusError = exports.TaskTransitionError = exports.TaskParentError = exports.TaskInvalidPriorityError = exports.TaskInvalidTypeError = exports.TaskInvalidOwnerError = exports.TaskOwnerRequiredError = exports.TaskBadSprintError = exports.TaskNotFoundError = exports.SprintNoneError = exports.SprintBadStatusError = exports.SprintTransitionError = exports.SprintInvalidError = exports.SprintNotFoundError = exports.SprintDuplicateError = exports.ProjectPathNotDirectoryError = exports.ProjectDbInaccessibleError = exports.ProjectResolutionError = exports.ProjectEnvNotFoundError = exports.ProjectFlagNotFoundError = exports.ProjectInvalidNameError = exports.ProjectNotFoundError = exports.ProjectCorruptDbError = exports.ProjectFolderNotFoundError = exports.ProjectFolderCreateError = exports.ProjectEmptyNameError = exports.ProjectPathExistsError = exports.DuplicateProjectError = exports.LockOrderingError = exports.LockRetryExhaustedError = exports.LockTimeoutError = exports.DatabaseBusyError = exports.MigrationValidationError = exports.MigrationScriptError = exports.MigrationYamlWriteError = exports.SchemaRelationArrayEmptyError = exports.MigrationChecksumMismatchError = exports.MigrationIntegrityError = exports.MigrationError = exports.ConnectionBusyError = exports.ConnectionError = exports.DatabaseCorruptError = exports.DatabaseDiskFullError = exports.DatabasePermissionDeniedError = exports.DatabaseParentDirMissingError = exports.CortexError = void 0;
+exports.DocSrcStorageError = exports.DocumentTypeUnknownError = exports.DocumentScanError = exports.DocumentNotFoundError = exports.DocumentMissingFieldError = exports.DocumentInvalidJsonError = exports.DocumentFileError = exports.DocumentDuplicateError = exports.GraphExportFormatError = exports.GraphDocTypeMappingNotFoundError = exports.GraphRelationNotFoundError = exports.GraphDuplicateRelationError = exports.GraphCardinalityError = exports.GraphTypeConstraintError = exports.GraphSelfRelationError = exports.GraphRelationTypeNotFoundError = exports.GraphEntityDuplicateError = exports.GraphEntityNotFoundError = exports.ConfigError = exports.RegistryReadError = exports.RegistryInvalidJsonError = exports.RegistryWriteError = exports.RegistryInvalidStructureError = exports.RegistryDirCreateError = exports.RegistryError = exports.CliShowFormatError = exports.CliFormatError = exports.CliActionError = exports.CliCmdError = exports.SpawnRoleError = exports.SpawnStateError = exports.SpawnSprintError = exports.TaskNotInActiveSprintError = exports.TaskNoActiveSprintError = exports.TaskInvalidFieldError = exports.TaskDbWriteFilePreservedError = exports.TestReportNotInSprintError = exports.TestReportBadSprintError = exports.TestReportNoSprintError = exports.TaskMissingIdError = exports.TaskDuplicateIdError = exports.TaskBadIdError = exports.TaskBadSprintRequiredError = exports.TaskNoSprintError = exports.TaskContentFileError = exports.TaskInlineFieldsRemovedError = exports.TaskOwnerReleaseError = exports.TaskOwnerPlanningError = exports.TaskNoopError = exports.StageOwnerError = void 0;
+exports.AuditFixError = exports.AuditReportFileError = exports.AuditSprintNotFoundError = exports.AuditCheckFailedError = exports.AuditUnknownCheckError = exports.InvalidProjectFolderError = exports.LockConflictError = exports.MigrationVersionError = exports.TaskOwnerReviewError = exports.TaskOwnerBacklogError = exports.LessonFileError = exports.LessonInvalidSeverityError = exports.LessonInvalidCategoryError = exports.LessonNoUpdateFieldsError = exports.LessonNotFoundError = exports.TestReportDuplicateIdError = exports.TestReportMissingIdError = exports.TestReportBadIdError = exports.TestReportContentFileError = exports.ReportNotFoundError = exports.ReportModuleNotFoundError = exports.TestReportReportPathRejectedError = exports.ReviewContentFileError = exports.ReviewContentRemovedError = exports.ReviewSprintRequiredError = exports.ReviewNotInSprintError = exports.ReviewDuplicateIdError = exports.ReviewMissingIdError = exports.ReviewBadIdError = exports.ReviewContentFileNotFoundError = exports.ReviewNotFoundError = exports.ReviewSprintNotFoundError = exports.DocumentInvalidSearchQueryError = exports.DocumentUnknownOptionError = exports.DocumentInvalidOrderByError = exports.DocSprintRequiredError = void 0;
+/** Base error class for all cortex-cli errors */
+class CortexError extends Error {
+    code;
+    details;
+    constructor(code, message, details) {
+        super(message);
+        this.name = 'CortexError';
+        this.code = code;
+        this.details = details;
+    }
+}
+exports.CortexError = CortexError;
+// ─── Database Layer Errors (FS-SS-001-0001) ───
+/** ERR-DB-001: Parent directory does not exist */
+class DatabaseParentDirMissingError extends CortexError {
+    constructor(path) {
+        super('ERR-DB-001', `Parent directory does not exist: ${path}`, { path });
+        this.name = 'DatabaseParentDirMissingError';
+    }
+}
+exports.DatabaseParentDirMissingError = DatabaseParentDirMissingError;
+/** ERR-DB-002: Permission denied */
+class DatabasePermissionDeniedError extends CortexError {
+    constructor(path, reason) {
+        super('ERR-DB-002', `Permission denied: cannot create ${path}${reason ? `: ${reason}` : ''}`, { path, reason });
+        this.name = 'DatabasePermissionDeniedError';
+    }
+}
+exports.DatabasePermissionDeniedError = DatabasePermissionDeniedError;
+/** ERR-DB-003: Disk full */
+class DatabaseDiskFullError extends CortexError {
+    constructor(path) {
+        super('ERR-DB-003', `Cannot create database: disk full`, { path });
+        this.name = 'DatabaseDiskFullError';
+    }
+}
+exports.DatabaseDiskFullError = DatabaseDiskFullError;
+/** ERR-DB-004: Database file exists but is not valid */
+class DatabaseCorruptError extends CortexError {
+    constructor(path) {
+        super('ERR-DB-004', `Database file exists but is not valid: ${path}`, { path });
+        this.name = 'DatabaseCorruptError';
+    }
+}
+exports.DatabaseCorruptError = DatabaseCorruptError;
+// ─── Connection Errors (FS-SS-001-0003) ───
+/** ERR-CONN-001: Cannot enable WAL mode */
+class ConnectionError extends CortexError {
+    constructor(message, details) {
+        super('ERR-CONN-001', message, details);
+        this.name = 'ConnectionError';
+    }
+}
+exports.ConnectionError = ConnectionError;
+/** ERR-CONN-002: Database busy at open time */
+class ConnectionBusyError extends CortexError {
+    constructor(dbPath) {
+        super('ERR-CONN-002', `Database busy at open: ${dbPath}`, { dbPath });
+        this.name = 'ConnectionBusyError';
+    }
+}
+exports.ConnectionBusyError = ConnectionBusyError;
+// ─── Migration Errors (FS-SS-001-0002) ───
+/** ERR-MIG-001: Migration SQL fails */
+class MigrationError extends CortexError {
+    constructor(message, details) {
+        super('ERR-MIG-001', message, details);
+        this.name = 'MigrationError';
+    }
+}
+exports.MigrationError = MigrationError;
+/** ERR-MIG-002: Schema integrity check failed after migration */
+class MigrationIntegrityError extends CortexError {
+    version;
+    missing;
+    constructor(versionOrMessage, missing) {
+        let message;
+        let details;
+        if (typeof versionOrMessage === 'string') {
+            // Legacy call: new MigrationIntegrityError('message')
+            message = versionOrMessage;
+            details = {};
+        }
+        else {
+            // Spec call: new MigrationIntegrityError(version, missing)
+            message = `Schema integrity check failed after migration v${versionOrMessage}: missing ${missing?.join(', ') ?? 'unknown'}`;
+            details = { version: versionOrMessage, missing };
+        }
+        super('ERR-MIG-002', message, details);
+        this.name = 'MigrationIntegrityError';
+        if (typeof versionOrMessage === 'number') {
+            this.version = versionOrMessage;
+            this.missing = missing;
+        }
+    }
+}
+exports.MigrationIntegrityError = MigrationIntegrityError;
+/** ERR-MIG-003: Checksum mismatch — blocked state */
+class MigrationChecksumMismatchError extends CortexError {
+    constructor(version, expected, actual) {
+        super('ERR-MIG-003', `Migration v${version} checksum mismatch: expected ${expected}, got ${actual}. Database is in a blocked state — no further operations are allowed. Restore from backup or re-initialize the project.`, { version, expected, actual });
+        this.name = 'MigrationChecksumMismatchError';
+    }
+}
+exports.MigrationChecksumMismatchError = MigrationChecksumMismatchError;
+// ─── Schema Validation Errors (SAD-0012) ───
+/** ERR-SCHEMA-006: Relation type would have empty from_types or to_types after array update */
+class SchemaRelationArrayEmptyError extends CortexError {
+    relationTypeName;
+    constructor(relationTypeName) {
+        super('ERR-SCHEMA-006', `Relation type "${relationTypeName}" would have empty from_types or to_types after update`, { relationTypeName });
+        this.name = 'SchemaRelationArrayEmptyError';
+        this.relationTypeName = relationTypeName;
+    }
+}
+exports.SchemaRelationArrayEmptyError = SchemaRelationArrayEmptyError;
+// ─── Schema Migration Orchestration Errors (SAD-0012, MOD-022/022a-d) ───
+/** ERR-MIGRATION-010: Cannot write YAML file during schema migration */
+class MigrationYamlWriteError extends CortexError {
+    filePath;
+    constructor(filePath, reason) {
+        super('ERR-MIGRATION-010', `Cannot write ${filePath}: ${reason}`, { filePath, reason });
+        this.name = 'MigrationYamlWriteError';
+        this.filePath = filePath;
+    }
+}
+exports.MigrationYamlWriteError = MigrationYamlWriteError;
+/** ERR-MIGRATION-011: Script execution failed during migration */
+class MigrationScriptError extends CortexError {
+    scriptPath;
+    constructor(scriptPath, reason) {
+        super('ERR-MIGRATION-011', `Migration script failed: ${scriptPath}: ${reason}`, { scriptPath, reason });
+        this.name = 'MigrationScriptError';
+        this.scriptPath = scriptPath;
+    }
+}
+exports.MigrationScriptError = MigrationScriptError;
+/** ERR-MIGRATION-012: Post-migration validation failed */
+class MigrationValidationError extends CortexError {
+    constructor(message) {
+        super('ERR-MIGRATION-012', message, {});
+        this.name = 'MigrationValidationError';
+    }
+}
+exports.MigrationValidationError = MigrationValidationError;
+// ─── Lock/Concurrency Errors (FS-SS-003-0007) ───
+/** ERR-LOCK-001: SQLite busy-level contention (DB-level write contention) */
+class DatabaseBusyError extends CortexError {
+    constructor(message, details) {
+        super('ERR-LOCK-001', message, details);
+        this.name = 'DatabaseBusyError';
+    }
+}
+exports.DatabaseBusyError = DatabaseBusyError;
+/** ERR-LOCK-002: Advisory lock timeout (held by another owner) */
+class LockTimeoutError extends CortexError {
+    lockName;
+    owner;
+    totalWaitMs;
+    constructor(lockName, owner, totalWaitMs) {
+        super('ERR-LOCK-002', `Lock timeout on "${lockName}": held by ${owner}`, { lockName, owner, totalWaitMs });
+        this.name = 'LockTimeoutError';
+        this.lockName = lockName;
+        this.owner = owner;
+        this.totalWaitMs = totalWaitMs;
+    }
+}
+exports.LockTimeoutError = LockTimeoutError;
+/** ERR-LOCK-003: Retry exhaustion */
+class LockRetryExhaustedError extends CortexError {
+    lockName;
+    owner;
+    retries;
+    totalWaitMs;
+    constructor(lockName, owner, retries, totalWaitMs) {
+        const message = `Failed to acquire "${lockName}" after ${retries} retries over ${totalWaitMs}ms (held by ${owner})`;
+        super('ERR-LOCK-003', message, { lockName, owner, retries, totalWaitMs });
+        this.name = 'LockRetryExhaustedError';
+        this.lockName = lockName;
+        this.owner = owner;
+        this.retries = retries;
+        this.totalWaitMs = totalWaitMs;
+    }
+}
+exports.LockRetryExhaustedError = LockRetryExhaustedError;
+/** ERR-LOCK-004: Lock ordering violation */
+class LockOrderingError extends CortexError {
+    lockName;
+    earlierName;
+    constructor(lockName, earlierName) {
+        super('ERR-LOCK-004', `Lock ordering violation: "${lockName}" must be acquired before "${earlierName}" per alphabetical ordering rule`, { lockName, earlierName });
+        this.name = 'LockOrderingError';
+        this.lockName = lockName;
+        this.earlierName = earlierName;
+    }
+}
+exports.LockOrderingError = LockOrderingError;
+// ─── Project Management Errors (FS-SS-002-0001..0008) ───
+/** ERR-PROJ-001: Duplicate project name in registry */
+class DuplicateProjectError extends CortexError {
+    projectName;
+    constructor(projectName) {
+        super('ERR-PROJ-001', `Project "${projectName}" already exists in the registry`, { projectName });
+        this.name = 'DuplicateProjectError';
+        this.projectName = projectName;
+    }
+}
+exports.DuplicateProjectError = DuplicateProjectError;
+/** ERR-PROJ-002: Path already exists (directory) */
+class ProjectPathExistsError extends CortexError {
+    path;
+    constructor(path) {
+        super('ERR-PROJ-002', `Path already exists: ${path}. Use 'register' for existing directories.`, { path });
+        this.name = 'ProjectPathExistsError';
+        this.path = path;
+    }
+}
+exports.ProjectPathExistsError = ProjectPathExistsError;
+/** ERR-PROJ-003: Empty or whitespace-only project name */
+class ProjectEmptyNameError extends CortexError {
+    constructor() {
+        super('ERR-PROJ-003', 'Project name cannot be empty');
+        this.name = 'ProjectEmptyNameError';
+    }
+}
+exports.ProjectEmptyNameError = ProjectEmptyNameError;
+/** ERR-PROJ-004: Cannot create folder */
+class ProjectFolderCreateError extends CortexError {
+    folder;
+    constructor(folder, reason) {
+        super('ERR-PROJ-004', `Cannot create folder: ${folder}${reason ? `: ${reason}` : ''}`, { folder, reason });
+        this.name = 'ProjectFolderCreateError';
+        this.folder = folder;
+    }
+}
+exports.ProjectFolderCreateError = ProjectFolderCreateError;
+/** ERR-PROJ-005: Folder does not exist */
+class ProjectFolderNotFoundError extends CortexError {
+    path;
+    constructor(path) {
+        super('ERR-PROJ-005', `Folder does not exist: ${path}`, { path });
+        this.name = 'ProjectFolderNotFoundError';
+        this.path = path;
+    }
+}
+exports.ProjectFolderNotFoundError = ProjectFolderNotFoundError;
+/** ERR-PROJ-006: Existing database is corrupt */
+class ProjectCorruptDbError extends CortexError {
+    path;
+    constructor(path) {
+        super('ERR-PROJ-006', `Existing database at ${path} is not valid`, { path });
+        this.name = 'ProjectCorruptDbError';
+        this.path = path;
+    }
+}
+exports.ProjectCorruptDbError = ProjectCorruptDbError;
+/** ERR-PROJ-007: Project not found in registry */
+class ProjectNotFoundError extends CortexError {
+    projectName;
+    constructor(projectName) {
+        super('ERR-PROJ-007', `Project "${projectName}" not found in registry`, { projectName });
+        this.name = 'ProjectNotFoundError';
+        this.projectName = projectName;
+    }
+}
+exports.ProjectNotFoundError = ProjectNotFoundError;
+/** ERR-PROJ-008: Invalid project name format */
+class ProjectInvalidNameError extends CortexError {
+    projectName;
+    constructor(projectName) {
+        super('ERR-PROJ-008', `Invalid project name "${projectName}": must be lowercase alphanumeric and hyphens, start with a letter, end with a letter or digit, no consecutive hyphens, 1–64 characters`, { projectName });
+        this.name = 'ProjectInvalidNameError';
+        this.projectName = projectName;
+    }
+}
+exports.ProjectInvalidNameError = ProjectInvalidNameError;
+/** ERR-PROJ-009: --project name not found in registry */
+class ProjectFlagNotFoundError extends ProjectNotFoundError {
+    constructor(projectName) {
+        // ProjectNotFoundError uses ERR-PROJ-007; we override in body
+        super(projectName);
+        this.code = 'ERR-PROJ-009';
+        this.message = `Project "${projectName}" specified via --project not found in registry`;
+        this.name = 'ProjectFlagNotFoundError';
+    }
+}
+exports.ProjectFlagNotFoundError = ProjectFlagNotFoundError;
+/** ERR-PROJ-010: Env var value not found in registry */
+class ProjectEnvNotFoundError extends ProjectNotFoundError {
+    constructor(projectName) {
+        super(projectName);
+        this.code = 'ERR-PROJ-010';
+        this.message = `Project "${projectName}" from CORTEX_CLI_PROJECT not found in registry`;
+        this.name = 'ProjectEnvNotFoundError';
+    }
+}
+exports.ProjectEnvNotFoundError = ProjectEnvNotFoundError;
+/** ERR-PROJ-011: No project could be resolved */
+class ProjectResolutionError extends CortexError {
+    attemptedMethods;
+    constructor(attemptedMethodsOrMessage) {
+        let message;
+        let methods;
+        if (typeof attemptedMethodsOrMessage === 'string') {
+            // Legacy call: new ProjectResolutionError('message')
+            message = attemptedMethodsOrMessage;
+            methods = [];
+        }
+        else {
+            // Spec call: new ProjectResolutionError(attemptedMethods)
+            methods = attemptedMethodsOrMessage;
+            const methodsList = methods.length > 0
+                ? ` Checked: ${methods.join('; ')}.`
+                : '';
+            message = `No project could be resolved.${methodsList} Use --project <name>, set CORTEX_CLI_PROJECT, configure a default with 'cortex-cli project default <name>', or run from a registered project directory.`;
+        }
+        super('ERR-PROJ-011', message, { attemptedMethods: methods });
+        this.name = 'ProjectResolutionError';
+        this.attemptedMethods = methods;
+    }
+}
+exports.ProjectResolutionError = ProjectResolutionError;
+/** ERR-PROJ-012: Database inaccessible for project */
+class ProjectDbInaccessibleError extends CortexError {
+    path;
+    constructor(path, reason) {
+        super('ERR-PROJ-012', `Project database is not accessible: ${path}${reason ? `: ${reason}` : ''}`, { path, reason });
+        this.name = 'ProjectDbInaccessibleError';
+        this.path = path;
+    }
+}
+exports.ProjectDbInaccessibleError = ProjectDbInaccessibleError;
+/** ERR-PROJ-013: Path exists but is not a directory (file or symlink) */
+class ProjectPathNotDirectoryError extends CortexError {
+    path;
+    constructor(path) {
+        super('ERR-PROJ-013', `Path exists but is not a directory: ${path}`, { path });
+        this.name = 'ProjectPathNotDirectoryError';
+        this.path = path;
+    }
+}
+exports.ProjectPathNotDirectoryError = ProjectPathNotDirectoryError;
+// ─── Sprint Lifecycle Errors (MOD-004) ───
+/** ERR-SPRINT-001: Duplicate sprint ID - sprint already exists */
+class SprintDuplicateError extends CortexError {
+    sprintId;
+    constructor(sprintId) {
+        super('ERR-SPRINT-001', `Sprint "${sprintId}" already exists`, { sprintId });
+        this.name = 'SprintDuplicateError';
+        this.sprintId = sprintId;
+    }
+}
+exports.SprintDuplicateError = SprintDuplicateError;
+/** ERR-SPRINT-002: Sprint not found */
+class SprintNotFoundError extends CortexError {
+    sprintId;
+    constructor(sprintId) {
+        super('ERR-SPRINT-002', `Sprint "${sprintId}" not found`, { sprintId });
+        this.name = 'SprintNotFoundError';
+        this.sprintId = sprintId;
+    }
+}
+exports.SprintNotFoundError = SprintNotFoundError;
+/** ERR-SPRINT-003: Sprint parameter is invalid (e.g. empty ID) */
+class SprintInvalidError extends CortexError {
+    constructor(reason) {
+        super('ERR-SPRINT-003', `Invalid sprint parameter: ${reason}`, { reason });
+        this.name = 'SprintInvalidError';
+    }
+}
+exports.SprintInvalidError = SprintInvalidError;
+/** ERR-SPRINT-004: Invalid sprint status transition */
+class SprintTransitionError extends CortexError {
+    currentStatus;
+    targetStatus;
+    allowedTransitions;
+    constructor(currentStatus, targetStatus, allowedTransitions) {
+        const allowed = allowedTransitions.join(', ');
+        super('ERR-SPRINT-004', `Invalid sprint transition: cannot move from "${currentStatus}" to "${targetStatus}". Allowed: ${allowed}`, { currentStatus, targetStatus, allowedTransitions });
+        this.name = 'SprintTransitionError';
+        this.currentStatus = currentStatus;
+        this.targetStatus = targetStatus;
+        this.allowedTransitions = allowedTransitions;
+    }
+}
+exports.SprintTransitionError = SprintTransitionError;
+/** ERR-SPRINT-005: Target sprint status is not a valid sprint status value */
+class SprintBadStatusError extends CortexError {
+    targetStatus;
+    constructor(targetStatus) {
+        super('ERR-SPRINT-005', `Invalid sprint status value: "${targetStatus}". Valid: PLANNING, IN EXECUTION, CLOSING, CLOSED`, { targetStatus });
+        this.name = 'SprintBadStatusError';
+        this.targetStatus = targetStatus;
+    }
+}
+exports.SprintBadStatusError = SprintBadStatusError;
+/** ERR-SPRINT-006: No sprint could be resolved (no sprints exist in the project) */
+class SprintNoneError extends CortexError {
+    constructor() {
+        super('ERR-SPRINT-006', 'No sprints found in this project. Use `cortex-cli sprint init <id>` to create one.', {});
+        this.name = 'SprintNoneError';
+    }
+}
+exports.SprintNoneError = SprintNoneError;
+// ─── Task/Kanban Lifecycle Errors (MOD-005) ───
+/** ERR-TASK-001: Task not found */
+class TaskNotFoundError extends CortexError {
+    taskId;
+    constructor(taskId, sprintId) {
+        const msg = sprintId
+            ? `Task "${taskId}" not found in sprint "${sprintId}"`
+            : `Task "${taskId}" not found`;
+        super('ERR-TASK-001', msg, { taskId, sprintId });
+        this.name = 'TaskNotFoundError';
+        this.taskId = taskId;
+    }
+}
+exports.TaskNotFoundError = TaskNotFoundError;
+/** ERR-TASK-002: Sprint does not exist or is closed when adding a task */
+class TaskBadSprintError extends CortexError {
+    sprintId;
+    reason;
+    constructor(sprintId, reason) {
+        const msg = reason
+            ? `Cannot add task to sprint "${sprintId}": ${reason}`
+            : `Cannot add task to sprint "${sprintId}": sprint not found or closed`;
+        super('ERR-TASK-002', msg, { sprintId, reason });
+        this.name = 'TaskBadSprintError';
+        this.sprintId = sprintId;
+        this.reason = reason;
+    }
+}
+exports.TaskBadSprintError = TaskBadSprintError;
+/** ERR-TASK-003: Owner role is required (empty/null) */
+class TaskOwnerRequiredError extends CortexError {
+    constructor() {
+        super('ERR-TASK-003', 'Task owner role is required', {});
+        this.name = 'TaskOwnerRequiredError';
+    }
+}
+exports.TaskOwnerRequiredError = TaskOwnerRequiredError;
+/** ERR-TASK-004: Owner role is not a valid role name */
+class TaskInvalidOwnerError extends CortexError {
+    owner;
+    validRoles;
+    constructor(owner, validRoles) {
+        const valid = validRoles.join(', ');
+        super('ERR-TASK-004', `Invalid owner role "${owner}". Valid roles: ${valid}`, { owner, validRoles });
+        this.name = 'TaskInvalidOwnerError';
+        this.owner = owner;
+        this.validRoles = validRoles;
+    }
+}
+exports.TaskInvalidOwnerError = TaskInvalidOwnerError;
+/** ERR-TASK-005: Task type is not a valid enum value */
+class TaskInvalidTypeError extends CortexError {
+    typeValue;
+    constructor(typeValue) {
+        super('ERR-TASK-005', `Invalid task type "${typeValue}". Valid: Feature, Bug, Chore`, { typeValue });
+        this.name = 'TaskInvalidTypeError';
+        this.typeValue = typeValue;
+    }
+}
+exports.TaskInvalidTypeError = TaskInvalidTypeError;
+/** ERR-TASK-006: Task priority is not a valid enum value */
+class TaskInvalidPriorityError extends CortexError {
+    priorityValue;
+    constructor(priorityValue) {
+        super('ERR-TASK-006', `Invalid priority "${priorityValue}". Valid: P0, P1, P2`, { priorityValue });
+        this.name = 'TaskInvalidPriorityError';
+        this.priorityValue = priorityValue;
+    }
+}
+exports.TaskInvalidPriorityError = TaskInvalidPriorityError;
+/** ERR-TASK-007: Parent task not found or invalid */
+class TaskParentError extends CortexError {
+    parentId;
+    reason;
+    constructor(parentId, reason) {
+        const msg = reason
+            ? `Invalid parent task "${parentId}": ${reason}`
+            : `Parent task "${parentId}" not found`;
+        super('ERR-TASK-007', msg, { parentId, reason });
+        this.name = 'TaskParentError';
+        this.parentId = parentId;
+        this.reason = reason;
+    }
+}
+exports.TaskParentError = TaskParentError;
+/** ERR-TASK-008: Invalid task state transition */
+class TaskTransitionError extends CortexError {
+    taskId;
+    currentState;
+    targetState;
+    allowedTransitions;
+    constructor(taskId, currentState, targetState, allowedTransitions) {
+        const allowed = allowedTransitions.join(', ');
+        super('ERR-TASK-008', `Invalid task transition for "${taskId}": cannot move from "${currentState}" to "${targetState}". Allowed: ${allowed}`, { taskId, currentState, targetState, allowedTransitions });
+        this.name = 'TaskTransitionError';
+        this.taskId = taskId;
+        this.currentState = currentState;
+        this.targetState = targetState;
+        this.allowedTransitions = allowedTransitions;
+    }
+}
+exports.TaskTransitionError = TaskTransitionError;
+/** ERR-TASK-009: Target status is not a valid task status value */
+class TaskBadStatusError extends CortexError {
+    targetStatus;
+    constructor(targetStatus) {
+        super('ERR-TASK-009', `Invalid task status "${targetStatus}". Valid: Backlog, To Do, In Progress, In Review, Done, Dropped`, { targetStatus });
+        this.name = 'TaskBadStatusError';
+        this.targetStatus = targetStatus;
+    }
+}
+exports.TaskBadStatusError = TaskBadStatusError;
+// ─── Stage Progression Errors (MOD-005, FS-SS-030-0001) ───
+/** ERR-STAGE-NOPROGRESS: Target stage is same as current */
+class StageNoProgressError extends CortexError {
+    taskId;
+    stage;
+    constructor(taskId, stage) {
+        super('ERR-STAGE-NOPROGRESS', `Task "${taskId}" is already in ${stage} stage`, { taskId, stage });
+        this.name = 'StageNoProgressError';
+        this.taskId = taskId;
+        this.stage = stage;
+    }
+}
+exports.StageNoProgressError = StageNoProgressError;
+/** ERR-STAGE-BACKWARD: Target stage is backward of current */
+class StageBackwardError extends CortexError {
+    currentStage;
+    targetStage;
+    constructor(currentStage, targetStage) {
+        super('ERR-STAGE-BACKWARD', `Cannot regress stage from ${currentStage} to ${targetStage}. Stage is forward-only.`, { currentStage, targetStage });
+        this.name = 'StageBackwardError';
+        this.currentStage = currentStage;
+        this.targetStage = targetStage;
+    }
+}
+exports.StageBackwardError = StageBackwardError;
+/** ERR-STAGE-INVALID: Target stage is not a valid stage value */
+class StageInvalidError extends CortexError {
+    stage;
+    constructor(stage) {
+        const valid = 'Planning, Requirement, Specification, Design, Test Plan, Implementation, Testing, Release';
+        super('ERR-STAGE-INVALID', `Invalid stage value "${stage}". Valid: ${valid}`, { stage });
+        this.name = 'StageInvalidError';
+        this.stage = stage;
+    }
+}
+exports.StageInvalidError = StageInvalidError;
+/** ERR-STAGE-LOCKED: Task is in Dropped status and cannot change stage */
+class StageLockedError extends CortexError {
+    taskId;
+    constructor(taskId) {
+        super('ERR-STAGE-LOCKED', `Task "${taskId}" is Dropped. Stage changes are not permitted.`, { taskId });
+        this.name = 'StageLockedError';
+        this.taskId = taskId;
+    }
+}
+exports.StageLockedError = StageLockedError;
+/** ERR-STAGE-OWNER: Owner validation failed for destination stage */
+class StageOwnerError extends CortexError {
+    stage;
+    owner;
+    constructor(stage, owner) {
+        super('ERR-STAGE-OWNER', `Owner must be captain for ${stage} stage. Update owner to captain first.`, { stage, owner });
+        this.name = 'StageOwnerError';
+        this.stage = stage;
+        this.owner = owner;
+    }
+}
+exports.StageOwnerError = StageOwnerError;
+/** ERR-TASK-010: No-op move (task is already in the target state) */
+class TaskNoopError extends CortexError {
+    taskId;
+    status;
+    constructor(taskId, status) {
+        super('ERR-TASK-010', `Task "${taskId}" is already in state "${status}"`, { taskId, status });
+        this.name = 'TaskNoopError';
+        this.taskId = taskId;
+        this.status = status;
+    }
+}
+exports.TaskNoopError = TaskNoopError;
+/** ERR-TASK-011: Captain-only restriction — only captain can own tasks in Planning stage */
+class TaskOwnerPlanningError extends CortexError {
+    owner;
+    constructor(owner) {
+        super('ERR-TASK-011', `Only "captain" can own tasks in Planning stage. Current owner: "${owner}"`, { owner });
+        this.name = 'TaskOwnerPlanningError';
+        this.owner = owner;
+    }
+}
+exports.TaskOwnerPlanningError = TaskOwnerPlanningError;
+/** ERR-TASK-012: Captain-only restriction — only captain can own tasks in Release stage */
+class TaskOwnerReleaseError extends CortexError {
+    owner;
+    constructor(owner) {
+        super('ERR-TASK-012', `Only "captain" can own tasks in Release stage. Current owner: "${owner}"`, { owner });
+        this.name = 'TaskOwnerReleaseError';
+        this.owner = owner;
+    }
+}
+exports.TaskOwnerReleaseError = TaskOwnerReleaseError;
+/** ERR-TASK-013: Inline content fields removed; use --content-file */
+class TaskInlineFieldsRemovedError extends CortexError {
+    constructor() {
+        super('ERR-TASK-013', '--description/--scope-in/--scope-out/--acceptance/--decisions/--dependencies are no longer supported; use --content-file');
+        this.name = 'TaskInlineFieldsRemovedError';
+    }
+}
+exports.TaskInlineFieldsRemovedError = TaskInlineFieldsRemovedError;
+/** ERR-TASK-014: Content file not found for task */
+class TaskContentFileError extends CortexError {
+    path;
+    constructor(path) {
+        super('ERR-TASK-014', `Content file not found: ${path}`, { path });
+        this.name = 'TaskContentFileError';
+        this.path = path;
+    }
+}
+exports.TaskContentFileError = TaskContentFileError;
+/** ERR-TASK-NOSPRINT: --sprint required for task show */
+class TaskNoSprintError extends CortexError {
+    constructor() {
+        super('ERR-TASK-NOSPRINT', '--sprint <sprint-id> is required');
+        this.name = 'TaskNoSprintError';
+    }
+}
+exports.TaskNoSprintError = TaskNoSprintError;
+/** ERR-TASK-BADSPRINT: Sprint not found for task show */
+class TaskBadSprintRequiredError extends CortexError {
+    sprintId;
+    constructor(sprintId) {
+        super('ERR-TASK-BADSPRINT', `Sprint "${sprintId}" not found`, { sprintId });
+        this.name = 'TaskBadSprintRequiredError';
+        this.sprintId = sprintId;
+    }
+}
+exports.TaskBadSprintRequiredError = TaskBadSprintRequiredError;
+/** ERR-TASK-BADID: Invalid task ID format (not 4-digit NNNN) */
+class TaskBadIdError extends CortexError {
+    taskId;
+    constructor(taskId) {
+        super('ERR-TASK-BADID', `Invalid task ID "${taskId}". Expected 4-digit zero-padded format (e.g., 0001).`, { taskId });
+        this.name = 'TaskBadIdError';
+        this.taskId = taskId;
+    }
+}
+exports.TaskBadIdError = TaskBadIdError;
+/** ERR-TASK-DUPID: Duplicate task ID */
+class TaskDuplicateIdError extends CortexError {
+    taskId;
+    constructor(taskId) {
+        super('ERR-TASK-DUPID', `Task "${taskId}" already exists`, { taskId });
+        this.name = 'TaskDuplicateIdError';
+        this.taskId = taskId;
+    }
+}
+exports.TaskDuplicateIdError = TaskDuplicateIdError;
+/** ERR-TASK-MISSINGID: Missing task ID (required for task add with positional <id>) */
+class TaskMissingIdError extends CortexError {
+    constructor() {
+        super('ERR-TASK-MISSINGID', '<id> is required (4-digit zero-padded, e.g., 0001)');
+        this.name = 'TaskMissingIdError';
+    }
+}
+exports.TaskMissingIdError = TaskMissingIdError;
+/** ERR-TESTREPORT-NOSPRINT: --sprint required for test-report show */
+class TestReportNoSprintError extends CortexError {
+    constructor() {
+        super('ERR-TESTREPORT-NOSPRINT', '--sprint <sprint-id> is required');
+        this.name = 'TestReportNoSprintError';
+    }
+}
+exports.TestReportNoSprintError = TestReportNoSprintError;
+/** ERR-TESTREPORT-BADSPRINT: Sprint not found for test-report show */
+class TestReportBadSprintError extends CortexError {
+    sprintId;
+    constructor(sprintId) {
+        super('ERR-TESTREPORT-BADSPRINT', `Sprint "${sprintId}" not found`, { sprintId });
+        this.name = 'TestReportBadSprintError';
+        this.sprintId = sprintId;
+    }
+}
+exports.TestReportBadSprintError = TestReportBadSprintError;
+/** ERR-TESTREPORT-004: Test report not found in sprint */
+class TestReportNotInSprintError extends CortexError {
+    reportId;
+    sprintId;
+    constructor(reportId, sprintId) {
+        const idStr = String(reportId);
+        super('ERR-TESTREPORT-004', `Test report "${idStr}" not found in sprint "${sprintId}"`, { reportId, sprintId });
+        this.name = 'TestReportNotInSprintError';
+        this.reportId = reportId;
+        this.sprintId = sprintId;
+    }
+}
+exports.TestReportNotInSprintError = TestReportNotInSprintError;
+/** ERR-TASK-015: DB write failed; file preserved */
+class TaskDbWriteFilePreservedError extends CortexError {
+    path;
+    constructor(path) {
+        super('ERR-TASK-015', `DB write failed; file preserved: ${path}`, { path });
+        this.name = 'TaskDbWriteFilePreservedError';
+        this.path = path;
+    }
+}
+exports.TaskDbWriteFilePreservedError = TaskDbWriteFilePreservedError;
+/** ERR-TASK-INVALID-FIELD: Prohibited field passed to task update — use task move instead */
+class TaskInvalidFieldError extends CortexError {
+    fieldName;
+    constructor(fieldName) {
+        super('ERR-TASK-INVALID-FIELD', `Field --${fieldName} is not permitted via task update. Use task move for ${fieldName} changes.`, { fieldName });
+        this.name = 'TaskInvalidFieldError';
+        this.fieldName = fieldName;
+    }
+}
+exports.TaskInvalidFieldError = TaskInvalidFieldError;
+/** ERR-TASK-NOACTIVESPRINT: No active sprint — task move requires active sprint */
+class TaskNoActiveSprintError extends CortexError {
+    constructor() {
+        super('ERR-TASK-NOACTIVESPRINT', 'No active sprint. task move requires an active sprint.');
+        this.name = 'TaskNoActiveSprintError';
+    }
+}
+exports.TaskNoActiveSprintError = TaskNoActiveSprintError;
+/** ERR-TASK-NOTINACTIVESPRINT: Task does not belong to the active sprint */
+class TaskNotInActiveSprintError extends CortexError {
+    taskId;
+    constructor(taskId) {
+        super('ERR-TASK-NOTINACTIVESPRINT', `Task ${taskId} does not belong to the active sprint.`, { taskId });
+        this.name = 'TaskNotInActiveSprintError';
+        this.taskId = taskId;
+    }
+}
+exports.TaskNotInActiveSprintError = TaskNotInActiveSprintError;
+// ─── Spawn Validation Errors (MOD-006) ───
+/** ERR-SPAWN-SPRINT: Sprint phase does not permit spawning (not IN EXECUTION) */
+class SpawnSprintError extends CortexError {
+    sprintId;
+    sprintStatus;
+    constructor(sprintId, sprintStatus) {
+        super('ERR-SPAWN-SPRINT', `Cannot spawn in sprint "${sprintId}": sprint must be IN EXECUTION, but is "${sprintStatus}"`, { sprintId, sprintStatus });
+        this.name = 'SpawnSprintError';
+        this.sprintId = sprintId;
+        this.sprintStatus = sprintStatus;
+    }
+}
+exports.SpawnSprintError = SpawnSprintError;
+/** ERR-SPAWN-STATE: Task state does not permit spawning (not In Progress) */
+class SpawnStateError extends CortexError {
+    taskId;
+    taskStatus;
+    constructor(taskId, taskStatus) {
+        super('ERR-SPAWN-STATE', `Cannot spawn from task "${taskId}": task must be In Progress, but is "${taskStatus}"`, { taskId, taskStatus });
+        this.name = 'SpawnStateError';
+        this.taskId = taskId;
+        this.taskStatus = taskStatus;
+    }
+}
+exports.SpawnStateError = SpawnStateError;
+/** ERR-SPAWN-ROLE: Role mismatch for spawn operation */
+class SpawnRoleError extends CortexError {
+    requiredRole;
+    providedRole;
+    constructor(requiredRole, providedRole) {
+        super('ERR-SPAWN-ROLE', `Spawn requires role "${requiredRole}", but "${providedRole}" was provided`, { requiredRole, providedRole });
+        this.name = 'SpawnRoleError';
+        this.requiredRole = requiredRole;
+        this.providedRole = providedRole;
+    }
+}
+exports.SpawnRoleError = SpawnRoleError;
+// ─── CLI Errors (MOD-007) ───
+/** ERR-CLI-001: Unknown subcommand */
+class CliCmdError extends CortexError {
+    subcommand;
+    constructor(subcommand, availableCommands) {
+        super('ERR-CLI-001', `Unknown command "${subcommand}". Available: ${availableCommands.join(', ')}`, { subcommand, availableCommands });
+        this.name = 'CliCmdError';
+        this.subcommand = subcommand;
+    }
+}
+exports.CliCmdError = CliCmdError;
+/** ERR-CLI-002: Unknown action for a subcommand */
+class CliActionError extends CortexError {
+    subcommand;
+    action;
+    constructor(subcommand, action, availableActions) {
+        super('ERR-CLI-002', `Unknown action "${action}" for ${subcommand}. Available: ${availableActions.join(', ')}`, { subcommand, action, availableActions });
+        this.name = 'CliActionError';
+        this.subcommand = subcommand;
+        this.action = action;
+    }
+}
+exports.CliActionError = CliActionError;
+/** ERR-CLI-003: Invalid format option */
+class CliFormatError extends CortexError {
+    format;
+    constructor(format) {
+        super('ERR-CLI-003', `Invalid format "${format}". Valid: table, json, markdown, quiet`, { format });
+        this.name = 'CliFormatError';
+        this.format = format;
+    }
+}
+exports.CliFormatError = CliFormatError;
+/** ERR-CLI-FORMAT: --format table is not valid for show commands */
+class CliShowFormatError extends CortexError {
+    format;
+    constructor(format) {
+        super('ERR-CLI-FORMAT', `--format ${format} is not valid for show commands`, { format });
+        this.name = 'CliShowFormatError';
+        this.format = format;
+    }
+}
+exports.CliShowFormatError = CliShowFormatError;
+// ─── Registry Errors (FS-SS-002-0010) ───
+/** Base registry error (ERR-REG-*) — legacy compat base class */
+class RegistryError extends CortexError {
+    constructor(reason, code = 'ERR-REG-003') {
+        super(code, `Registry error: ${reason}`, { reason });
+        this.name = 'RegistryError';
+    }
+}
+exports.RegistryError = RegistryError;
+/** ERR-REG-001: Cannot create config directory */
+class RegistryDirCreateError extends RegistryError {
+    constructor(reason) {
+        super(reason, 'ERR-REG-001');
+        this.code = 'ERR-REG-001';
+        this.message = `Cannot create config directory: ${reason}`;
+        this.name = 'RegistryDirCreateError';
+    }
+}
+exports.RegistryDirCreateError = RegistryDirCreateError;
+/** ERR-REG-002: Registry file has invalid structure */
+class RegistryInvalidStructureError extends RegistryError {
+    constructor(reason) {
+        super(reason, 'ERR-REG-002');
+        this.message = `Registry file has invalid structure: ${reason}`;
+        this.name = 'RegistryInvalidStructureError';
+    }
+}
+exports.RegistryInvalidStructureError = RegistryInvalidStructureError;
+/** ERR-REG-003: Cannot write registry file */
+class RegistryWriteError extends RegistryError {
+    constructor(reason) {
+        super(reason, 'ERR-REG-003');
+        this.message = `Cannot write registry file: ${reason}`;
+        this.name = 'RegistryWriteError';
+    }
+}
+exports.RegistryWriteError = RegistryWriteError;
+/** ERR-REG-004: Registry file is not valid JSON */
+class RegistryInvalidJsonError extends RegistryError {
+    constructor(reason) {
+        super(reason, 'ERR-REG-004');
+        this.message = `Registry file is not valid JSON: ${reason}`;
+        this.name = 'RegistryInvalidJsonError';
+    }
+}
+exports.RegistryInvalidJsonError = RegistryInvalidJsonError;
+/** ERR-REG-005: Cannot read registry file */
+class RegistryReadError extends RegistryError {
+    constructor(reason) {
+        super(reason, 'ERR-REG-005');
+        this.message = `Cannot read registry file: ${reason}`;
+        this.name = 'RegistryReadError';
+    }
+}
+exports.RegistryReadError = RegistryReadError;
+// ─── Config Errors (config.json — NOT registry) ───
+// ConfigError is for config.json operations.
+// Registry errors use the ERR-REG-* codes above.
+/** Config file is corrupt or invalid */
+class ConfigError extends CortexError {
+    constructor(message, details) {
+        super('ERR-CFG-001', message, details);
+        this.name = 'ConfigError';
+    }
+}
+exports.ConfigError = ConfigError;
+// ─── Graph Errors (MOD-008/009/010/011) ───
+/** ERR-GRAPH-002: Entity not found */
+class GraphEntityNotFoundError extends CortexError {
+    entityId;
+    constructor(entityId) {
+        super('ERR-GRAPH-002', `Entity "${entityId}" not found`, { entityId });
+        this.name = 'GraphEntityNotFoundError';
+        this.entityId = entityId;
+    }
+}
+exports.GraphEntityNotFoundError = GraphEntityNotFoundError;
+/** ERR-GRAPH-003: Duplicate entity ID */
+class GraphEntityDuplicateError extends CortexError {
+    entityId;
+    constructor(entityId) {
+        super('ERR-GRAPH-003', `Entity "${entityId}" already exists`, { entityId });
+        this.name = 'GraphEntityDuplicateError';
+        this.entityId = entityId;
+    }
+}
+exports.GraphEntityDuplicateError = GraphEntityDuplicateError;
+/** ERR-GRAPH-004: Relation type not found */
+class GraphRelationTypeNotFoundError extends CortexError {
+    typeName;
+    constructor(typeName) {
+        super('ERR-GRAPH-004', `Relation type "${typeName}" not found`, { typeName });
+        this.name = 'GraphRelationTypeNotFoundError';
+        this.typeName = typeName;
+    }
+}
+exports.GraphRelationTypeNotFoundError = GraphRelationTypeNotFoundError;
+/** ERR-GRAPH-005: Self-relation not allowed */
+class GraphSelfRelationError extends CortexError {
+    entityId;
+    relType;
+    constructor(entityId, relType) {
+        super('ERR-GRAPH-005', `Self-relation not allowed: entity "${entityId}" cannot relate to itself via "${relType}"`, { entityId, relType });
+        this.name = 'GraphSelfRelationError';
+        this.entityId = entityId;
+        this.relType = relType;
+    }
+}
+exports.GraphSelfRelationError = GraphSelfRelationError;
+/** ERR-GRAPH-006: Type constraint violation */
+class GraphTypeConstraintError extends CortexError {
+    relType;
+    direction;
+    actualType;
+    allowedTypes;
+    constructor(relType, direction, actualType, allowedTypes) {
+        super('ERR-GRAPH-006', `Type constraint violation on "${relType}": ${direction} entity type "${actualType}" not in allowed types [${allowedTypes.join(', ')}]`, { relType, direction, actualType, allowedTypes });
+        this.name = 'GraphTypeConstraintError';
+        this.relType = relType;
+        this.direction = direction;
+        this.actualType = actualType;
+        this.allowedTypes = allowedTypes;
+    }
+}
+exports.GraphTypeConstraintError = GraphTypeConstraintError;
+/** ERR-GRAPH-007: Cardinality constraint violation */
+class GraphCardinalityError extends CortexError {
+    relType;
+    cardinality;
+    entityId;
+    constructor(relType, cardinality, entityId) {
+        super('ERR-GRAPH-007', `Cardinality violation on "${relType}" (${cardinality}): entity "${entityId}" already has maximum allowed relations`, { relType, cardinality, entityId });
+        this.name = 'GraphCardinalityError';
+        this.relType = relType;
+        this.cardinality = cardinality;
+        this.entityId = entityId;
+    }
+}
+exports.GraphCardinalityError = GraphCardinalityError;
+/** ERR-GRAPH-008: Duplicate relation */
+class GraphDuplicateRelationError extends CortexError {
+    fromId;
+    relType;
+    toId;
+    constructor(fromId, relType, toId) {
+        super('ERR-GRAPH-008', `Duplicate relation: ${fromId} -[${relType}]-> ${toId} already exists`, { fromId, relType, toId });
+        this.name = 'GraphDuplicateRelationError';
+        this.fromId = fromId;
+        this.relType = relType;
+        this.toId = toId;
+    }
+}
+exports.GraphDuplicateRelationError = GraphDuplicateRelationError;
+/** ERR-GRAPH-009: Relation not found */
+class GraphRelationNotFoundError extends CortexError {
+    relationId;
+    constructor(relationId) {
+        super('ERR-GRAPH-009', `Relation ${relationId} not found`, { relationId });
+        this.name = 'GraphRelationNotFoundError';
+        this.relationId = relationId;
+    }
+}
+exports.GraphRelationNotFoundError = GraphRelationNotFoundError;
+/** ERR-GRAPH-010: No entity type mapping for document type (MOD-021) */
+class GraphDocTypeMappingNotFoundError extends CortexError {
+    docType;
+    constructor(docType) {
+        super('ERR-GRAPH-010', `No entity type mapping for document type "${docType}". Valid document types are: AD, FR, FS, MDL, NFR, NFS, QA, SAD, SRC, TC, TR, TS, URD, US`, { docType });
+        this.name = 'GraphDocTypeMappingNotFoundError';
+        this.docType = docType;
+    }
+}
+exports.GraphDocTypeMappingNotFoundError = GraphDocTypeMappingNotFoundError;
+/** ERR-GRAPH-EXPORT-FORMAT: Unsupported graph export format */
+class GraphExportFormatError extends CortexError {
+    format;
+    supported;
+    constructor(format, supported) {
+        super('ERR-GRAPH-EXPORT-FORMAT', `Unsupported export format: ${format}. Supported: ${supported.join(', ')}`, { format, supported });
+        this.name = 'GraphExportFormatError';
+        this.format = format;
+        this.supported = supported;
+    }
+}
+exports.GraphExportFormatError = GraphExportFormatError;
+// ─── Document Errors (MOD-012) ───
+/** ERR-DOC-001: Duplicate document ID */
+class DocumentDuplicateError extends CortexError {
+    docId;
+    constructor(docId) {
+        super('ERR-DOC-001', `Document "${docId}" already exists`, { docId });
+        this.name = 'DocumentDuplicateError';
+        this.docId = docId;
+    }
+}
+exports.DocumentDuplicateError = DocumentDuplicateError;
+/** ERR-DOC-002: Content file not found or unreadable */
+class DocumentFileError extends CortexError {
+    path;
+    constructor(path, reason) {
+        super('ERR-DOC-002', `Cannot read file: ${path}${reason ? `: ${reason}` : ''}`, { path, reason });
+        this.name = 'DocumentFileError';
+        this.path = path;
+    }
+}
+exports.DocumentFileError = DocumentFileError;
+/** ERR-DOC-003: Invalid JSON in metadata */
+class DocumentInvalidJsonError extends CortexError {
+    constructor(field) {
+        super('ERR-DOC-003', `Invalid JSON in ${field}`, { field });
+        this.name = 'DocumentInvalidJsonError';
+    }
+}
+exports.DocumentInvalidJsonError = DocumentInvalidJsonError;
+/** ERR-DOC-004: Missing required field */
+class DocumentMissingFieldError extends CortexError {
+    field;
+    constructor(field) {
+        super('ERR-DOC-004', `Missing required field: ${field}`, { field });
+        this.name = 'DocumentMissingFieldError';
+        this.field = field;
+    }
+}
+exports.DocumentMissingFieldError = DocumentMissingFieldError;
+/** ERR-DOC-005: Document not found */
+class DocumentNotFoundError extends CortexError {
+    docId;
+    constructor(docId) {
+        super('ERR-DOC-005', `Document "${docId}" not found`, { docId });
+        this.name = 'DocumentNotFoundError';
+        this.docId = docId;
+    }
+}
+exports.DocumentNotFoundError = DocumentNotFoundError;
+/** ERR-DOC-006: Vault scan error */
+class DocumentScanError extends CortexError {
+    vaultPath;
+    constructor(vaultPath, reason) {
+        super('ERR-DOC-006', `Vault scan error: ${reason}`, { vaultPath, reason });
+        this.name = 'DocumentScanError';
+        this.vaultPath = vaultPath;
+    }
+}
+exports.DocumentScanError = DocumentScanError;
+/** ERR-DOC-TYPE-UNKNOWN: Unknown document type rejected pre-transaction (FS-SS-012-0011 v2) */
+class DocumentTypeUnknownError extends CortexError {
+    invalidType;
+    constructor(invalidType) {
+        const validTypes = ['AD', 'FR', 'FS', 'MDL', 'NFR', 'NFS', 'QA', 'SAD', 'SRC', 'TC', 'TR', 'TS', 'URD', 'US'];
+        super('ERR-DOC-TYPE-UNKNOWN', `Document type "${invalidType}" is not a valid document type. Valid types are: ${validTypes.join(', ')}`, { invalidType, validTypes });
+        this.name = 'DocumentTypeUnknownError';
+        this.invalidType = invalidType;
+    }
+}
+exports.DocumentTypeUnknownError = DocumentTypeUnknownError;
+/** ERR-DOC-SRC-STORAGE: SRC documents require filesystem storage (reject --content-file) */
+class DocSrcStorageError extends CortexError {
+    constructor() {
+        super('ERR-DOC-SRC-STORAGE', 'SRC documents require filesystem storage (omit --content-file for SRC documents)', {});
+        this.name = 'DocSrcStorageError';
+    }
+}
+exports.DocSrcStorageError = DocSrcStorageError;
+/** ERR-DOC-SPRINT-REQUIRED: Sprint-scoped doc type registered without --sprint */
+class DocSprintRequiredError extends CortexError {
+    docType;
+    constructor(docType) {
+        super('ERR-DOC-SPRINT-REQUIRED', `Document type "${docType}" requires --sprint`, { docType });
+        this.name = 'DocSprintRequiredError';
+        this.docType = docType;
+    }
+}
+exports.DocSprintRequiredError = DocSprintRequiredError;
+/** ERR-DOC-012: Invalid order-by field for doc list/search */
+class DocumentInvalidOrderByError extends CortexError {
+    field;
+    validFields;
+    constructor(field) {
+        const validFields = ['id', 'type', 'title', 'created', 'updated'];
+        super('ERR-DOC-012', `Invalid order-by field "${field}". Valid fields: ${validFields.join(', ')}`, { field, validFields });
+        this.name = 'DocumentInvalidOrderByError';
+        this.field = field;
+        this.validFields = validFields;
+    }
+}
+exports.DocumentInvalidOrderByError = DocumentInvalidOrderByError;
+/** ERR-DOC-UNKNOWN-OPTION: Unsupported option rejected per URD-G001 */
+class DocumentUnknownOptionError extends CortexError {
+    optionName;
+    commandName;
+    constructor(optionName, commandName) {
+        super('ERR-DOC-UNKNOWN-OPTION', `--${optionName} is no longer supported for doc ${commandName} (removed by URD-G001)`, { optionName, commandName });
+        this.name = 'DocumentUnknownOptionError';
+        this.optionName = optionName;
+        this.commandName = commandName;
+    }
+}
+exports.DocumentUnknownOptionError = DocumentUnknownOptionError;
+/** ERR-DOC-011: Invalid search query (malformed FTS5 syntax) */
+class DocumentInvalidSearchQueryError extends CortexError {
+    query;
+    constructor(query, reason) {
+        super('ERR-DOC-011', `Invalid search query: ${query}${reason ? `: ${reason}` : ''}`, { query, reason });
+        this.name = 'DocumentInvalidSearchQueryError';
+        this.query = query;
+    }
+}
+exports.DocumentInvalidSearchQueryError = DocumentInvalidSearchQueryError;
+// ─── Review Errors (MOD-013) ───
+/** ERR-REVIEW-001: Sprint not found for review */
+class ReviewSprintNotFoundError extends CortexError {
+    sprintId;
+    constructor(sprintId) {
+        super('ERR-REVIEW-001', `Sprint "${sprintId}" not found for review`, { sprintId });
+        this.name = 'ReviewSprintNotFoundError';
+        this.sprintId = sprintId;
+    }
+}
+exports.ReviewSprintNotFoundError = ReviewSprintNotFoundError;
+/** ERR-REVIEW-002: Review not found */
+class ReviewNotFoundError extends CortexError {
+    reviewId;
+    constructor(reviewId) {
+        super('ERR-REVIEW-002', `Review ${reviewId} not found`, { reviewId });
+        this.name = 'ReviewNotFoundError';
+        this.reviewId = reviewId;
+    }
+}
+exports.ReviewNotFoundError = ReviewNotFoundError;
+/** ERR-REVIEW-004: Content file not found for review add */
+class ReviewContentFileNotFoundError extends CortexError {
+    path;
+    constructor(path) {
+        super('ERR-REVIEW-004', `Content file not found: ${path}`, { path });
+        this.name = 'ReviewContentFileNotFoundError';
+        this.path = path;
+    }
+}
+exports.ReviewContentFileNotFoundError = ReviewContentFileNotFoundError;
+/** ERR-REVIEW-BADID: Invalid review ID format (not 4 digits) */
+class ReviewBadIdError extends CortexError {
+    reviewId;
+    constructor(reviewId) {
+        super('ERR-REVIEW-BADID', `Invalid ID format: ${reviewId}. ID must be exactly 4 digits (e.g., 0001).`, { reviewId });
+        this.name = 'ReviewBadIdError';
+        this.reviewId = reviewId;
+    }
+}
+exports.ReviewBadIdError = ReviewBadIdError;
+/** ERR-REVIEW-MISSINGID: --id is required for review add */
+class ReviewMissingIdError extends CortexError {
+    constructor() {
+        super('ERR-REVIEW-MISSINGID', '--id is required');
+        this.name = 'ReviewMissingIdError';
+    }
+}
+exports.ReviewMissingIdError = ReviewMissingIdError;
+/** ERR-REVIEW-DUPID: Duplicate review ID in the same sprint */
+class ReviewDuplicateIdError extends CortexError {
+    reviewId;
+    sprintId;
+    constructor(reviewId, sprintId) {
+        super('ERR-REVIEW-DUPID', `Review ID ${reviewId} already exists in sprint ${sprintId}`, { reviewId, sprintId });
+        this.name = 'ReviewDuplicateIdError';
+        this.reviewId = reviewId;
+        this.sprintId = sprintId;
+    }
+}
+exports.ReviewDuplicateIdError = ReviewDuplicateIdError;
+/** ERR-REVIEW-006: Review not found in specified sprint */
+class ReviewNotInSprintError extends CortexError {
+    reviewNum;
+    sprintId;
+    constructor(reviewNum, sprintId) {
+        super('ERR-REVIEW-006', `Review ${reviewNum} not found in sprint "${sprintId}"`, { reviewNum, sprintId });
+        this.name = 'ReviewNotInSprintError';
+        this.reviewNum = reviewNum;
+        this.sprintId = sprintId;
+    }
+}
+exports.ReviewNotInSprintError = ReviewNotInSprintError;
+/** ERR-REVIEW-007: --sprint option required for review show */
+class ReviewSprintRequiredError extends CortexError {
+    constructor() {
+        super('ERR-REVIEW-007', '--sprint <sprint-id> is required for review show');
+        this.name = 'ReviewSprintRequiredError';
+    }
+}
+exports.ReviewSprintRequiredError = ReviewSprintRequiredError;
+/** ERR-REVIEW-008: --content is no longer supported */
+class ReviewContentRemovedError extends CortexError {
+    constructor() {
+        super('ERR-REVIEW-008', '--content is no longer supported; use --content-file');
+        this.name = 'ReviewContentRemovedError';
+    }
+}
+exports.ReviewContentRemovedError = ReviewContentRemovedError;
+/** ERR-REVIEW-009: Content file not found (legacy compat) */
+class ReviewContentFileError extends CortexError {
+    path;
+    constructor(path, reason) {
+        super('ERR-REVIEW-009', `Content file not found: ${path}${reason ? `: ${reason}` : ''}`, { path, reason });
+        this.name = 'ReviewContentFileError';
+        this.path = path;
+    }
+}
+exports.ReviewContentFileError = ReviewContentFileError;
+// ─── Test Report Errors (MOD-013) ───
+/** ERR-TESTREPORT-001: --report-path is no longer supported */
+class TestReportReportPathRejectedError extends CortexError {
+    constructor() {
+        super('ERR-TESTREPORT-001', '--report-path is no longer supported; use --content-file');
+        this.name = 'TestReportReportPathRejectedError';
+    }
+}
+exports.TestReportReportPathRejectedError = TestReportReportPathRejectedError;
+/** ERR-REPORT-001: Module not found */
+class ReportModuleNotFoundError extends CortexError {
+    moduleId;
+    constructor(moduleId) {
+        super('ERR-REPORT-001', `Module "${moduleId}" not found`, { moduleId });
+        this.name = 'ReportModuleNotFoundError';
+        this.moduleId = moduleId;
+    }
+}
+exports.ReportModuleNotFoundError = ReportModuleNotFoundError;
+/** ERR-REPORT-002: Test report not found */
+class ReportNotFoundError extends CortexError {
+    reportId;
+    constructor(reportId) {
+        super('ERR-REPORT-002', `Test report ${reportId} not found`, { reportId });
+        this.name = 'ReportNotFoundError';
+        this.reportId = reportId;
+    }
+}
+exports.ReportNotFoundError = ReportNotFoundError;
+/** ERR-TESTREPORT-002: Content file not found */
+class TestReportContentFileError extends CortexError {
+    path;
+    constructor(path) {
+        super('ERR-TESTREPORT-002', `Content file not found: ${path}`, { path });
+        this.name = 'TestReportContentFileError';
+        this.path = path;
+    }
+}
+exports.TestReportContentFileError = TestReportContentFileError;
+/** ERR-TESTREPORT-BADID: Invalid test-report ID format (not 4 digits) */
+class TestReportBadIdError extends CortexError {
+    testReportId;
+    constructor(testReportId) {
+        super('ERR-TESTREPORT-BADID', `Invalid ID format: ${testReportId}. ID must be exactly 4 digits (e.g., 0001).`, { testReportId });
+        this.name = 'TestReportBadIdError';
+        this.testReportId = testReportId;
+    }
+}
+exports.TestReportBadIdError = TestReportBadIdError;
+/** ERR-TESTREPORT-MISSINGID: --id is required for test-report add */
+class TestReportMissingIdError extends CortexError {
+    constructor() {
+        super('ERR-TESTREPORT-MISSINGID', '--id is required');
+        this.name = 'TestReportMissingIdError';
+    }
+}
+exports.TestReportMissingIdError = TestReportMissingIdError;
+/** ERR-TESTREPORT-DUPID: Duplicate test-report ID in the same sprint */
+class TestReportDuplicateIdError extends CortexError {
+    testReportId;
+    sprintId;
+    constructor(testReportId, sprintId) {
+        super('ERR-TESTREPORT-DUPID', `Test report ID ${testReportId} already exists in sprint ${sprintId}`, { testReportId, sprintId });
+        this.name = 'TestReportDuplicateIdError';
+        this.testReportId = testReportId;
+        this.sprintId = sprintId;
+    }
+}
+exports.TestReportDuplicateIdError = TestReportDuplicateIdError;
+// ─── Lesson Errors (MOD-013) ───
+/** ERR-LESSON-001: No lesson has been recorded for this project (singleton) */
+class LessonNotFoundError extends CortexError {
+    constructor() {
+        super('ERR-LESSON-001', 'No lesson has been recorded for this project');
+        this.name = 'LessonNotFoundError';
+    }
+}
+exports.LessonNotFoundError = LessonNotFoundError;
+/** ERR-LESSON-002: No update fields provided */
+class LessonNoUpdateFieldsError extends CortexError {
+    constructor() {
+        super('ERR-LESSON-002', 'No update fields provided');
+        this.name = 'LessonNoUpdateFieldsError';
+    }
+}
+exports.LessonNoUpdateFieldsError = LessonNoUpdateFieldsError;
+/** ERR-LESSON-005: Invalid category enum value */
+class LessonInvalidCategoryError extends CortexError {
+    category;
+    constructor(category) {
+        super('ERR-LESSON-005', `Invalid category "${category}". Valid: Process, Technical, Tool, Model`, { category });
+        this.name = 'LessonInvalidCategoryError';
+        this.category = category;
+    }
+}
+exports.LessonInvalidCategoryError = LessonInvalidCategoryError;
+/** ERR-LESSON-006: Invalid severity enum value */
+class LessonInvalidSeverityError extends CortexError {
+    severity;
+    constructor(severity) {
+        super('ERR-LESSON-006', `Invalid severity "${severity}". Valid: critical, major, minor, suggestion`, { severity });
+        this.name = 'LessonInvalidSeverityError';
+        this.severity = severity;
+    }
+}
+exports.LessonInvalidSeverityError = LessonInvalidSeverityError;
+/** ERR-LESSON-007: Content file not found */
+class LessonFileError extends CortexError {
+    path;
+    constructor(path, reason) {
+        super('ERR-LESSON-007', `Content file not found: ${path}${reason ? `: ${reason}` : ''}`, { path, reason });
+        this.name = 'LessonFileError';
+        this.path = path;
+    }
+}
+exports.LessonFileError = LessonFileError;
+// ─── Legacy aliases for backward compatibility ───
+// These are proper subclasses that preserve their .name for test compatibility.
+// New code must use the canonical names and ERR-* codes above.
+/** @deprecated Use TaskOwnerPlanningError instead */
+class TaskOwnerBacklogError extends TaskOwnerPlanningError {
+    constructor(owner) {
+        super(owner);
+        this.name = 'TaskOwnerBacklogError';
+    }
+}
+exports.TaskOwnerBacklogError = TaskOwnerBacklogError;
+/** @deprecated Use TaskOwnerReleaseError instead */
+class TaskOwnerReviewError extends TaskOwnerReleaseError {
+    constructor(owner) {
+        super(owner);
+        this.name = 'TaskOwnerReviewError';
+    }
+}
+exports.TaskOwnerReviewError = TaskOwnerReviewError;
+/** @deprecated Use MigrationIntegrityError instead */
+class MigrationVersionError extends MigrationIntegrityError {
+    constructor(versionOrMessage, missing) {
+        super(versionOrMessage, missing);
+        this.name = 'MigrationVersionError';
+    }
+}
+exports.MigrationVersionError = MigrationVersionError;
+/** @deprecated Use LockTimeoutError (ERR-LOCK-002) instead */
+class LockConflictError extends LockTimeoutError {
+    constructor(lockName, owner, totalWaitMs = 0) {
+        super(lockName, owner, totalWaitMs);
+        this.name = 'LockConflictError';
+    }
+}
+exports.LockConflictError = LockConflictError;
+/** @deprecated Use ProjectFolderNotFoundError (ERR-PROJ-005) or ProjectFolderCreateError (ERR-PROJ-004) instead */
+class InvalidProjectFolderError extends ProjectFolderCreateError {
+    constructor(folder, reason) {
+        super(folder, reason);
+        this.name = 'InvalidProjectFolderError';
+    }
+}
+exports.InvalidProjectFolderError = InvalidProjectFolderError;
+// ─── Audit Errors (MOD-023) ───
+/** ERR-AUDIT-001: Unknown check name in --checks list */
+class AuditUnknownCheckError extends CortexError {
+    constructor(checkName, knownChecks) {
+        super('ERR-AUDIT-001', `Unknown audit check: "${checkName}". Known checks: ${knownChecks.join(', ')}`, { checkName, knownChecks });
+        this.name = 'AuditUnknownCheckError';
+    }
+}
+exports.AuditUnknownCheckError = AuditUnknownCheckError;
+/** ERR-AUDIT-002: One or more audit checks failed */
+class AuditCheckFailedError extends CortexError {
+    constructor(failedCount) {
+        super('ERR-AUDIT-002', `${failedCount} audit check(s) failed`, { failedCount });
+        this.name = 'AuditCheckFailedError';
+    }
+}
+exports.AuditCheckFailedError = AuditCheckFailedError;
+/** ERR-AUDIT-003: --sprint ID does not exist */
+class AuditSprintNotFoundError extends CortexError {
+    constructor(sprintId) {
+        super('ERR-AUDIT-003', `Sprint not found: "${sprintId}"`, { sprintId });
+        this.name = 'AuditSprintNotFoundError';
+    }
+}
+exports.AuditSprintNotFoundError = AuditSprintNotFoundError;
+/** ERR-AUDIT-004: Cannot write report file */
+class AuditReportFileError extends CortexError {
+    constructor(filePath, reason) {
+        super('ERR-AUDIT-004', `Cannot write report file "${filePath}": ${reason}`, { filePath, reason });
+        this.name = 'AuditReportFileError';
+    }
+}
+exports.AuditReportFileError = AuditReportFileError;
+/** ERR-AUDIT-005: Fix transaction failed */
+class AuditFixError extends CortexError {
+    constructor(reason) {
+        super('ERR-AUDIT-005', `Fix transaction failed: ${reason}`, { reason });
+        this.name = 'AuditFixError';
+    }
+}
+exports.AuditFixError = AuditFixError;
+//# sourceMappingURL=errors.js.map