@mx-space/cli 0.15.0 → 0.15.1

package/dist/src/domain/errors.d.ts

@@ -0,0 +1,336 @@
+declare const AuthMissing_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "AuthMissing";
+} & Readonly<A>;
+export declare class AuthMissing extends AuthMissing_base<{
+    readonly message?: string;
+    readonly details?: unknown;
+    readonly hint?: string;
+}> {
+}
+declare const AuthExpired_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "AuthExpired";
+} & Readonly<A>;
+export declare class AuthExpired extends AuthExpired_base<{
+    readonly message?: string;
+    readonly details?: unknown;
+    readonly hint?: string;
+}> {
+}
+declare const AuthDenied_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "AuthDenied";
+} & Readonly<A>;
+export declare class AuthDenied extends AuthDenied_base<{
+    readonly message?: string;
+    readonly details?: unknown;
+    readonly hint?: string;
+}> {
+}
+declare const AuthProbe_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "AuthProbe";
+} & Readonly<A>;
+export declare class AuthProbe extends AuthProbe_base<{
+    readonly message?: string;
+    readonly details?: unknown;
+    readonly hint?: string;
+    readonly cause?: unknown;
+}> {
+}
+declare const NetworkTimeout_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "NetworkTimeout";
+} & Readonly<A>;
+export declare class NetworkTimeout extends NetworkTimeout_base<{
+    readonly message?: string;
+    readonly url?: string;
+    readonly details?: unknown;
+    readonly hint?: string;
+}> {
+}
+declare const NetworkDns_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "NetworkDns";
+} & Readonly<A>;
+export declare class NetworkDns extends NetworkDns_base<{
+    readonly message?: string;
+    readonly host?: string;
+    readonly details?: unknown;
+    readonly hint?: string;
+}> {
+}
+declare const NetworkRefused_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "NetworkRefused";
+} & Readonly<A>;
+export declare class NetworkRefused extends NetworkRefused_base<{
+    readonly message?: string;
+    readonly url?: string;
+    readonly details?: unknown;
+    readonly hint?: string;
+}> {
+}
+declare const ValidationFailed_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ValidationFailed";
+} & Readonly<A>;
+export declare class ValidationFailed extends ValidationFailed_base<{
+    readonly message?: string;
+    readonly details?: unknown;
+    readonly hint?: string;
+}> {
+}
+declare const ValidationXml_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ValidationXml";
+} & Readonly<A>;
+export declare class ValidationXml extends ValidationXml_base<{
+    readonly message?: string;
+    readonly line?: number;
+    readonly details?: unknown;
+    readonly hint?: string;
+    readonly cause?: unknown;
+}> {
+}
+declare const ValidationJson_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ValidationJson";
+} & Readonly<A>;
+export declare class ValidationJson extends ValidationJson_base<{
+    readonly message?: string;
+    readonly details?: unknown;
+    readonly hint?: string;
+    readonly cause?: unknown;
+}> {
+}
+declare const ServerError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ServerError";
+} & Readonly<A>;
+export declare class ServerError extends ServerError_base<{
+    readonly message?: string;
+    readonly status?: number;
+    readonly details?: unknown;
+    readonly hint?: string;
+}> {
+}
+declare const ResourceNotFound_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ResourceNotFound";
+} & Readonly<A>;
+export declare class ResourceNotFound extends ResourceNotFound_base<{
+    readonly message?: string;
+    readonly kind?: string;
+    readonly ref?: string;
+    readonly details?: unknown;
+    readonly hint?: string;
+}> {
+}
+declare const ConfigMissingApiUrl_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ConfigMissingApiUrl";
+} & Readonly<A>;
+export declare class ConfigMissingApiUrl extends ConfigMissingApiUrl_base<{
+    readonly message?: string;
+    readonly details?: unknown;
+    readonly hint?: string;
+}> {
+}
+declare const ConfigMissingToken_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ConfigMissingToken";
+} & Readonly<A>;
+export declare class ConfigMissingToken extends ConfigMissingToken_base<{
+    readonly message?: string;
+    readonly details?: unknown;
+    readonly hint?: string;
+}> {
+}
+declare const ConfigMigrationFailed_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ConfigMigrationFailed";
+} & Readonly<A>;
+export declare class ConfigMigrationFailed extends ConfigMigrationFailed_base<{
+    readonly message?: string;
+    readonly details?: unknown;
+    readonly hint?: string;
+    readonly cause?: unknown;
+}> {
+}
+declare const ProfileNotFound_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ProfileNotFound";
+} & Readonly<A>;
+export declare class ProfileNotFound extends ProfileNotFound_base<{
+    readonly message?: string;
+    readonly name?: string;
+    readonly details?: unknown;
+    readonly hint?: string;
+}> {
+}
+declare const ProfileNoneActive_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ProfileNoneActive";
+} & Readonly<A>;
+export declare class ProfileNoneActive extends ProfileNoneActive_base<{
+    readonly message?: string;
+    readonly details?: unknown;
+    readonly hint?: string;
+}> {
+}
+declare const ProfileInvalidName_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ProfileInvalidName";
+} & Readonly<A>;
+export declare class ProfileInvalidName extends ProfileInvalidName_base<{
+    readonly message?: string;
+    readonly name?: string;
+    readonly details?: unknown;
+    readonly hint?: string;
+}> {
+}
+declare const WriteRequiresExplicit_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "WriteRequiresExplicit";
+} & Readonly<A>;
+export declare class WriteRequiresExplicit extends WriteRequiresExplicit_base<{
+    readonly message?: string;
+    readonly profile?: string;
+    readonly apiUrl?: string;
+    readonly details?: unknown;
+    readonly hint?: string;
+}> {
+}
+declare const UpdateDevEnvironment_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "UpdateDevEnvironment";
+} & Readonly<A>;
+export declare class UpdateDevEnvironment extends UpdateDevEnvironment_base<{
+    readonly message?: string;
+    readonly details?: unknown;
+    readonly hint?: string;
+}> {
+}
+declare const UpdateTransientInstall_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "UpdateTransientInstall";
+} & Readonly<A>;
+export declare class UpdateTransientInstall extends UpdateTransientInstall_base<{
+    readonly message?: string;
+    readonly details?: unknown;
+    readonly hint?: string;
+}> {
+}
+declare const UpdatePmUnknown_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "UpdatePmUnknown";
+} & Readonly<A>;
+export declare class UpdatePmUnknown extends UpdatePmUnknown_base<{
+    readonly message?: string;
+    readonly details?: unknown;
+    readonly hint?: string;
+}> {
+}
+declare const UpdateRegistryUnreachable_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "UpdateRegistryUnreachable";
+} & Readonly<A>;
+export declare class UpdateRegistryUnreachable extends UpdateRegistryUnreachable_base<{
+    readonly message?: string;
+    readonly details?: unknown;
+    readonly hint?: string;
+}> {
+}
+declare const UpdateNodeIncompatible_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "UpdateNodeIncompatible";
+} & Readonly<A>;
+export declare class UpdateNodeIncompatible extends UpdateNodeIncompatible_base<{
+    readonly message?: string;
+    readonly details?: unknown;
+    readonly hint?: string;
+}> {
+}
+declare const UpdateSpawnFailed_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "UpdateSpawnFailed";
+} & Readonly<A>;
+export declare class UpdateSpawnFailed extends UpdateSpawnFailed_base<{
+    readonly message?: string;
+    readonly details?: unknown;
+    readonly hint?: string;
+}> {
+}
+declare const UpdatePermissionDenied_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "UpdatePermissionDenied";
+} & Readonly<A>;
+export declare class UpdatePermissionDenied extends UpdatePermissionDenied_base<{
+    readonly message?: string;
+    readonly details?: unknown;
+    readonly hint?: string;
+}> {
+}
+declare const ArgvParse_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ArgvParse";
+} & Readonly<A>;
+export declare class ArgvParse extends ArgvParse_base<{
+    readonly message?: string;
+    readonly details?: unknown;
+    readonly hint?: string;
+}> {
+}
+declare const ChapterNotFound_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ChapterNotFound";
+} & Readonly<A>;
+export declare class ChapterNotFound extends ChapterNotFound_base<{
+    readonly message?: string;
+    readonly slug?: string;
+    readonly details?: unknown;
+    readonly hint?: string;
+}> {
+}
+declare const SkillCorpusEmpty_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "SkillCorpusEmpty";
+} & Readonly<A>;
+export declare class SkillCorpusEmpty extends SkillCorpusEmpty_base<{
+    readonly message?: string;
+    readonly details?: unknown;
+    readonly hint?: string;
+    readonly cause?: unknown;
+}> {
+}
+declare const AiTaskCreateFailed_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "AiTaskCreateFailed";
+} & Readonly<A>;
+export declare class AiTaskCreateFailed extends AiTaskCreateFailed_base<{
+    readonly message?: string;
+    readonly details?: unknown;
+    readonly hint?: string;
+    readonly cause?: unknown;
+}> {
+}
+declare const AiTaskFailed_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "AiTaskFailed";
+} & Readonly<A>;
+export declare class AiTaskFailed extends AiTaskFailed_base<{
+    readonly message?: string;
+    readonly taskId?: string;
+    readonly status?: string;
+    readonly details?: unknown;
+    readonly hint?: string;
+}> {
+}
+declare const AiRecordNotFound_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "AiRecordNotFound";
+} & Readonly<A>;
+export declare class AiRecordNotFound extends AiRecordNotFound_base<{
+    readonly message?: string;
+    readonly kind?: string;
+    readonly ref?: string;
+    readonly details?: unknown;
+    readonly hint?: string;
+}> {
+}
+declare const Generic_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "Generic";
+} & Readonly<A>;
+export declare class Generic extends Generic_base<{
+    readonly message?: string;
+    readonly details?: unknown;
+    readonly hint?: string;
+    readonly cause?: unknown;
+}> {
+}
+export type CliError = AuthMissing | AuthExpired | AuthDenied | AuthProbe | NetworkTimeout | NetworkDns | NetworkRefused | ValidationFailed | ValidationXml | ValidationJson | ServerError | ResourceNotFound | ConfigMissingApiUrl | ConfigMissingToken | ConfigMigrationFailed | ProfileNotFound | ProfileNoneActive | ProfileInvalidName | WriteRequiresExplicit | UpdateDevEnvironment | UpdateTransientInstall | UpdatePmUnknown | UpdateRegistryUnreachable | UpdateNodeIncompatible | UpdateSpawnFailed | UpdatePermissionDenied | ArgvParse | ChapterNotFound | SkillCorpusEmpty | AiTaskCreateFailed | AiTaskFailed | AiRecordNotFound | Generic;
+export type CliErrorTag = CliError['_tag'];
+export declare const tagToCode: Record<CliErrorTag, string>;
+export declare const codeForTag: (tag: CliErrorTag) => string;
+export declare const exitCodeForTag: (tag: CliErrorTag) => number;
+export declare const exitCodeForError: (err: unknown) => number;
+export declare const defaultMessageFor: (tag: CliErrorTag) => string;
+export interface ErrorEnvelope {
+    readonly ok: false;
+    readonly code: string;
+    readonly message: string;
+    readonly details?: unknown;
+    readonly hint?: string;
+}
+export declare const toErrorEnvelope: (err: CliError) => ErrorEnvelope;
+export {};

package/dist/src/domain/errors.js

@@ -0,0 +1,239 @@
+import { Data } from 'effect';
+// ---------------------------------------------------------------------------
+// TaggedError tree (one class per legacy MxsErrorCode entry)
+// ---------------------------------------------------------------------------
+// auth.*
+export class AuthMissing extends Data.TaggedError('AuthMissing') {
+}
+export class AuthExpired extends Data.TaggedError('AuthExpired') {
+}
+export class AuthDenied extends Data.TaggedError('AuthDenied') {
+}
+export class AuthProbe extends Data.TaggedError('AuthProbe') {
+}
+// network.*
+export class NetworkTimeout extends Data.TaggedError('NetworkTimeout') {
+}
+export class NetworkDns extends Data.TaggedError('NetworkDns') {
+}
+export class NetworkRefused extends Data.TaggedError('NetworkRefused') {
+}
+// validation.*
+export class ValidationFailed extends Data.TaggedError('ValidationFailed') {
+}
+export class ValidationXml extends Data.TaggedError('ValidationXml') {
+}
+export class ValidationJson extends Data.TaggedError('ValidationJson') {
+}
+// server.error
+export class ServerError extends Data.TaggedError('ServerError') {
+}
+// resource.not_found
+export class ResourceNotFound extends Data.TaggedError('ResourceNotFound') {
+}
+// config.*
+export class ConfigMissingApiUrl extends Data.TaggedError('ConfigMissingApiUrl') {
+}
+export class ConfigMissingToken extends Data.TaggedError('ConfigMissingToken') {
+}
+export class ConfigMigrationFailed extends Data.TaggedError('ConfigMigrationFailed') {
+}
+// profile.*
+export class ProfileNotFound extends Data.TaggedError('ProfileNotFound') {
+}
+export class ProfileNoneActive extends Data.TaggedError('ProfileNoneActive') {
+}
+export class ProfileInvalidName extends Data.TaggedError('ProfileInvalidName') {
+}
+export class WriteRequiresExplicit extends Data.TaggedError('WriteRequiresExplicit') {
+}
+// update.*
+export class UpdateDevEnvironment extends Data.TaggedError('UpdateDevEnvironment') {
+}
+export class UpdateTransientInstall extends Data.TaggedError('UpdateTransientInstall') {
+}
+export class UpdatePmUnknown extends Data.TaggedError('UpdatePmUnknown') {
+}
+export class UpdateRegistryUnreachable extends Data.TaggedError('UpdateRegistryUnreachable') {
+}
+export class UpdateNodeIncompatible extends Data.TaggedError('UpdateNodeIncompatible') {
+}
+export class UpdateSpawnFailed extends Data.TaggedError('UpdateSpawnFailed') {
+}
+export class UpdatePermissionDenied extends Data.TaggedError('UpdatePermissionDenied') {
+}
+// argv.*
+export class ArgvParse extends Data.TaggedError('ArgvParse') {
+}
+// skill.*
+export class ChapterNotFound extends Data.TaggedError('ChapterNotFound') {
+}
+export class SkillCorpusEmpty extends Data.TaggedError('SkillCorpusEmpty') {
+}
+// ai.*
+export class AiTaskCreateFailed extends Data.TaggedError('AiTaskCreateFailed') {
+}
+export class AiTaskFailed extends Data.TaggedError('AiTaskFailed') {
+}
+export class AiRecordNotFound extends Data.TaggedError('AiRecordNotFound') {
+}
+// generic
+export class Generic extends Data.TaggedError('Generic') {
+}
+// Wire-format `code` strings. MUST stay byte-equal to the legacy
+// `MxsErrorCode` table in `src/core/errors.ts` so envelope output and
+// existing test fixtures keep matching.
+export const tagToCode = {
+    AuthMissing: 'auth.missing',
+    AuthExpired: 'auth.expired',
+    AuthDenied: 'auth.denied',
+    AuthProbe: 'auth.probe',
+    NetworkTimeout: 'network.timeout',
+    NetworkDns: 'network.dns',
+    NetworkRefused: 'network.refused',
+    ValidationFailed: 'validation.failed',
+    ValidationXml: 'validation.xml',
+    ValidationJson: 'validation.json',
+    ServerError: 'server.error',
+    ResourceNotFound: 'resource.not_found',
+    ConfigMissingApiUrl: 'config.missing.api_url',
+    ConfigMissingToken: 'config.missing.token',
+    ConfigMigrationFailed: 'config.migration.failed',
+    ProfileNotFound: 'profile.not_found',
+    ProfileNoneActive: 'profile.none_active',
+    ProfileInvalidName: 'profile.invalid_name',
+    WriteRequiresExplicit: 'profile.write_requires_explicit',
+    UpdateDevEnvironment: 'update.dev_environment',
+    UpdateTransientInstall: 'update.transient_install',
+    UpdatePmUnknown: 'update.pm_unknown',
+    UpdateRegistryUnreachable: 'update.registry_unreachable',
+    UpdateNodeIncompatible: 'update.node_incompatible',
+    UpdateSpawnFailed: 'update.spawn_failed',
+    UpdatePermissionDenied: 'update.permission_denied',
+    ArgvParse: 'argv.parse',
+    ChapterNotFound: 'skill.chapter_not_found',
+    SkillCorpusEmpty: 'skill.corpus_empty',
+    AiTaskCreateFailed: 'ai.task.create_failed',
+    AiTaskFailed: 'ai.task.failed',
+    AiRecordNotFound: 'ai.record.not_found',
+    Generic: 'generic',
+};
+export const codeForTag = (tag) => tagToCode[tag];
+// ---------------------------------------------------------------------------
+// Exit codes — mirror legacy `exitCodeForError`
+// ---------------------------------------------------------------------------
+export const exitCodeForTag = (tag) => {
+    switch (tag) {
+        case 'ArgvParse': {
+            return 2;
+        }
+        case 'AuthMissing':
+        case 'AuthExpired':
+        case 'AuthDenied':
+        case 'AuthProbe': {
+            return 3;
+        }
+        case 'NetworkTimeout':
+        case 'NetworkDns':
+        case 'NetworkRefused':
+        case 'WriteRequiresExplicit':
+        case 'ProfileNoneActive': {
+            return 4;
+        }
+        case 'ValidationFailed':
+        case 'ValidationXml':
+        case 'ValidationJson':
+        case 'ProfileInvalidName':
+        case 'ConfigMissingApiUrl':
+        case 'ConfigMissingToken': {
+            return 5;
+        }
+        case 'ServerError': {
+            return 6;
+        }
+        case 'ResourceNotFound':
+        case 'ChapterNotFound':
+        case 'AiRecordNotFound': {
+            return 7;
+        }
+        case 'UpdatePmUnknown': {
+            return 70;
+        }
+        case 'UpdatePermissionDenied': {
+            return 73;
+        }
+        case 'UpdateRegistryUnreachable': {
+            return 75;
+        }
+        default: {
+            return 1;
+        }
+    }
+};
+export const exitCodeForError = (err) => {
+    if (typeof err === 'object' &&
+        err !== null &&
+        '_tag' in err &&
+        typeof err._tag === 'string' &&
+        err._tag in tagToCode) {
+        return exitCodeForTag(err._tag);
+    }
+    return 1;
+};
+// ---------------------------------------------------------------------------
+// Default messages (used when an error is constructed without one)
+// ---------------------------------------------------------------------------
+const defaultMessages = {
+    AuthMissing: 'not authenticated',
+    AuthExpired: 'authentication required',
+    AuthDenied: 'permission denied',
+    AuthProbe: 'cannot detect auth endpoint',
+    NetworkTimeout: 'network request timed out',
+    NetworkDns: 'dns lookup failed',
+    NetworkRefused: 'connection refused',
+    ValidationFailed: 'validation failed',
+    ValidationXml: 'failed to parse LiteXML',
+    ValidationJson: 'failed to parse JSON',
+    ServerError: 'server error',
+    ResourceNotFound: 'resource not found',
+    ConfigMissingApiUrl: 'API URL is not configured',
+    ConfigMissingToken: 'auth token is not configured',
+    ConfigMigrationFailed: 'legacy config migration failed',
+    ProfileNotFound: 'profile not found',
+    ProfileNoneActive: 'no active profile',
+    ProfileInvalidName: 'invalid profile name',
+    WriteRequiresExplicit: 'write blocked: active profile is production; pass --profile explicitly',
+    UpdateDevEnvironment: 'cannot self-update from a dev environment',
+    UpdateTransientInstall: 'cannot self-update from a transient install',
+    UpdatePmUnknown: 'cannot determine package manager for self-update',
+    UpdateRegistryUnreachable: 'npm registry is unreachable',
+    UpdateNodeIncompatible: 'installed Node.js does not satisfy required engine',
+    UpdateSpawnFailed: 'failed to spawn package manager',
+    UpdatePermissionDenied: 'permission denied while writing to install prefix',
+    ArgvParse: 'failed to parse arguments',
+    ChapterNotFound: 'skill chapter not found',
+    SkillCorpusEmpty: 'skill corpus is empty',
+    AiTaskCreateFailed: 'failed to create AI task',
+    AiTaskFailed: 'AI task did not succeed',
+    AiRecordNotFound: 'AI record not found',
+    Generic: 'mxs error',
+};
+export const defaultMessageFor = (tag) => defaultMessages[tag];
+const hasOwn = (obj, key) => typeof obj === 'object' && obj !== null && key in obj;
+export const toErrorEnvelope = (err) => {
+    const tag = err._tag;
+    const code = codeForTag(tag);
+    const message = hasOwn(err, 'message') && typeof err.message === 'string' && err.message
+        ? err.message
+        : defaultMessageFor(tag);
+    const envelope = { ok: false, code, message };
+    if (hasOwn(err, 'details') && err.details !== undefined) {
+        envelope.details = err.details;
+    }
+    if (hasOwn(err, 'hint') &&
+        typeof err.hint === 'string' &&
+        err.hint.length > 0) {
+        envelope.hint = err.hint;
+    }
+    return envelope;
+};

package/dist/src/domain/gate.d.ts

@@ -0,0 +1,14 @@
+export type HttpMethod = 'GET' | 'HEAD' | 'OPTIONS' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+export interface ResolvedGateInput {
+    readonly apiUrl: string;
+    readonly profileName: string | null;
+    readonly isProduction: boolean;
+    readonly profileExplicit: boolean;
+    readonly urlOverridden: boolean;
+}
+export interface GateDecision {
+    readonly allow: boolean;
+    readonly message?: string;
+    readonly hint?: string;
+}
+export declare const decideWriteGate: (resolved: ResolvedGateInput, method: HttpMethod) => GateDecision;

package/dist/src/domain/gate.js

@@ -0,0 +1,18 @@
+const SAFE_METHODS = new Set(['GET', 'HEAD', 'OPTIONS']);
+export const decideWriteGate = (resolved, method) => {
+    if (SAFE_METHODS.has(method))
+        return { allow: true };
+    if (!resolved.isProduction)
+        return { allow: true };
+    if (resolved.profileExplicit)
+        return { allow: true };
+    if (resolved.urlOverridden)
+        return { allow: true };
+    const name = resolved.profileName ?? 'unknown';
+    const url = resolved.apiUrl;
+    return {
+        allow: false,
+        message: `write blocked: active profile '${name}' (${url}) is production`,
+        hint: `active profile '${name}' is production; retry with --profile ${name} or MXS_PROFILE=${name}`,
+    };
+};

package/dist/src/domain/payload.d.ts

@@ -0,0 +1,64 @@
+import type { Path } from '@effect/platform';
+import { FileSystem } from '@effect/platform';
+import { Effect } from 'effect';
+import { Lexical } from '../services/Lexical';
+import { type EnvelopeKind, type EnvelopeMeta, type ParsedEnvelope } from './envelope';
+import { ValidationFailed, ValidationXml } from './errors';
+export type ContentFormat = 'lexical' | 'markdown';
+export interface PostFlagInputs {
+    title?: string;
+    slug?: string;
+    category?: string;
+    content?: string;
+    format?: ContentFormat;
+    summary?: string;
+    state?: 'publish' | 'draft';
+    tags?: string[];
+    copyright?: boolean;
+    pin?: string;
+    pinOrder?: number;
+    related?: string[];
+    meta?: string;
+    file?: string;
+}
+export interface NoteFlagInputs {
+    title?: string;
+    slug?: string;
+    topic?: string;
+    content?: string;
+    format?: ContentFormat;
+    state?: 'publish' | 'draft';
+    mood?: string;
+    weather?: string;
+    publicAt?: string;
+    password?: string;
+    bookmark?: boolean;
+    coords?: string;
+    location?: string;
+    images?: string;
+    meta?: string;
+    file?: string;
+}
+export interface PageFlagInputs {
+    title?: string;
+    slug?: string;
+    subtitle?: string;
+    order?: number;
+    content?: string;
+    format?: ContentFormat;
+    meta?: string;
+    file?: string;
+}
+export interface BuiltPayload {
+    readonly payload: Record<string, unknown>;
+    readonly envelopeMeta?: EnvelopeMeta;
+    readonly contentSource?: 'flag' | 'envelope' | 'none';
+}
+export declare const loadEnvelopeIfAny: (filePath: string | undefined, kind: EnvelopeKind) => Effect.Effect<ParsedEnvelope | null, ValidationFailed | ValidationXml, FileSystem.FileSystem | Path.Path>;
+export declare const buildPostPayload: (flags: PostFlagInputs) => Effect.Effect<BuiltPayload, ValidationFailed | ValidationXml, Lexical | FileSystem.FileSystem | Path.Path>;
+export declare const buildNotePayload: (flags: NoteFlagInputs) => Effect.Effect<BuiltPayload, ValidationFailed | ValidationXml, Lexical | FileSystem.FileSystem | Path.Path>;
+export declare const buildPagePayload: (flags: PageFlagInputs) => Effect.Effect<BuiltPayload, ValidationFailed | ValidationXml, Lexical | FileSystem.FileSystem | Path.Path>;
+export declare const emptyPayload: (format: ContentFormat) => Effect.Effect<{
+    content: string;
+    text: string;
+}, never, Lexical>;