cognitive-modules-cli 2.2.1 → 2.2.7

package/dist/commands/add.d.ts

@@ -1,8 +1,13 @@
 /**
- * Add command - Install modules from GitHub
+ * Add command - Install modules from GitHub or Registry
  *
- * cog add ziel-io/cognitive-modules -m code-simplifier
- * cog add https://github.com/org/repo --module name --tag v1.0.0
+ * From Registry:
+ *   cog add code-reviewer
+ *   cog add code-reviewer@2.0.0
+ *
+ * From GitHub:
+ *   cog add ziel-io/cognitive-modules -m code-simplifier
+ *   cog add https://github.com/org/repo --module name --tag v1.0.0
  */
 import type { CommandContext, CommandResult } from '../types.js';
 export interface AddOptions {
@@ -10,25 +15,39 @@ export interface AddOptions {
     name?: string;
     branch?: string;
     tag?: string;
+    registry?: string;
+}
+export interface InstallInfo {
+    source: string;
+    githubUrl: string;
+    modulePath?: string;
+    tag?: string;
+    branch?: string;
+    version?: string;
+    installedAt: string;
+    installedTime: string;
+    /** Registry module name if installed from registry */
+    registryModule?: string;
+    /** Registry URL if installed from a custom registry */
+    registryUrl?: string;
 }
 interface InstallManifest {
-    [moduleName: string]: {
-        source: string;
-        githubUrl: string;
-        modulePath?: string;
-        tag?: string;
-        branch?: string;
-        version?: string;
-        installedAt: string;
-        installedTime: string;
-    };
+    [moduleName: string]: InstallInfo;
 }
 /**
  * Get installation info for a module
  */
 export declare function getInstallInfo(moduleName: string): Promise<InstallManifest[string] | null>;
+/**
+ * Add a module from the registry
+ */
+export declare function addFromRegistry(moduleSpec: string, ctx: CommandContext, options?: AddOptions): Promise<CommandResult>;
 /**
  * Add a module from GitHub
  */
-export declare function add(url: string, ctx: CommandContext, options?: AddOptions): Promise<CommandResult>;
+export declare function addFromGitHub(url: string, ctx: CommandContext, options?: AddOptions): Promise<CommandResult>;
+/**
+ * Add a module from GitHub or Registry (auto-detect source)
+ */
+export declare function add(source: string, ctx: CommandContext, options?: AddOptions): Promise<CommandResult>;
 export {};

package/dist/commands/add.js

@@ -1,15 +1,23 @@
 /**
- * Add command - Install modules from GitHub
+ * Add command - Install modules from GitHub or Registry
  *
- * cog add ziel-io/cognitive-modules -m code-simplifier
- * cog add https://github.com/org/repo --module name --tag v1.0.0
+ * From Registry:
+ *   cog add code-reviewer
+ *   cog add code-reviewer@2.0.0
+ *
+ * From GitHub:
+ *   cog add ziel-io/cognitive-modules -m code-simplifier
+ *   cog add https://github.com/org/repo --module name --tag v1.0.0
  */
-import { createWriteStream, existsSync, mkdirSync, rmSync, readdirSync, statSync, copyFileSync } from 'node:fs';
+import { createWriteStream, existsSync, mkdirSync, rmSync, readdirSync, statSync, copyFileSync, lstatSync } from 'node:fs';
 import { writeFile, readFile, mkdir } from 'node:fs/promises';
-import { pipeline } from 'node:stream/promises';
+import { pipeline, finished } from 'node:stream/promises';
 import { Readable } from 'node:stream';
-import { join, basename } from 'node:path';
+import { join, basename, dirname, resolve, sep, isAbsolute } from 'node:path';
 import { homedir, tmpdir } from 'node:os';
+import { createHash } from 'node:crypto';
+import { RegistryClient } from '../registry/client.js';
+import { extractTarGzFile } from '../registry/tar.js';
 // Module storage paths
 const USER_MODULES_DIR = join(homedir(), '.cognitive', 'modules');
 const INSTALLED_MANIFEST = join(homedir(), '.cognitive', 'installed.json');
@@ -33,6 +41,33 @@ function parseGitHubUrl(url) {
         fullUrl: `https://github.com/${org}/${repo}`,
     };
 }
+function assertSafeModuleName(name) {
+    const trimmed = name.trim();
+    if (!trimmed) {
+        throw new Error('Invalid module name: empty');
+    }
+    if (trimmed.includes('..') || trimmed.includes('/') || trimmed.includes('\\')) {
+        throw new Error(`Invalid module name: ${name}`);
+    }
+    if (isAbsolute(trimmed)) {
+        throw new Error(`Invalid module name (absolute path not allowed): ${name}`);
+    }
+    return trimmed;
+}
+function resolveModuleTarget(moduleName) {
+    const safeName = assertSafeModuleName(moduleName);
+    const targetPath = resolve(USER_MODULES_DIR, safeName);
+    const root = resolve(USER_MODULES_DIR) + sep;
+    if (!targetPath.startsWith(root)) {
+        throw new Error(`Invalid module name (path traversal): ${moduleName}`);
+    }
+    return targetPath;
+}
+function isPathWithinRoot(rootDir, targetPath) {
+    const root = resolve(rootDir);
+    const target = resolve(targetPath);
+    return target === root || target.startsWith(root + sep);
+}
 /**
  * Download and extract ZIP from GitHub
  */
@@ -56,6 +91,9 @@ async function downloadAndExtract(org, repo, ref, isTag) {
     await pipeline(Readable.fromWeb(response.body), fileStream);
     // Extract using built-in unzip (available on most systems)
     const { execSync } = await import('node:child_process');
+    // Validate ZIP entries to avoid path traversal (Zip Slip)
+    const listing = execSync(`unzip -Z1 "${zipPath}"`, { stdio: 'pipe' }).toString('utf-8');
+    assertSafeZipEntries(listing);
     execSync(`unzip -q "${zipPath}" -d "${tempDir}"`, { stdio: 'pipe' });
     // Find extracted directory
     const entries = readdirSync(tempDir).filter(e => e !== 'repo.zip' && statSync(join(tempDir, e)).isDirectory());
@@ -64,6 +102,22 @@ async function downloadAndExtract(org, repo, ref, isTag) {
     }
     return join(tempDir, entries[0]);
 }
+/**
+ * Validate ZIP listing to prevent path traversal.
+ */
+function assertSafeZipEntries(listing) {
+    const entries = listing.split(/\r?\n/).map(e => e.trim()).filter(Boolean);
+    for (const entry of entries) {
+        const normalized = entry.replace(/\\/g, '/');
+        if (normalized.startsWith('/') || /^[a-zA-Z]:\//.test(normalized)) {
+            throw new Error(`Unsafe ZIP entry (absolute path): ${entry}`);
+        }
+        const parts = normalized.split('/');
+        if (parts.includes('..')) {
+            throw new Error(`Unsafe ZIP entry (path traversal): ${entry}`);
+        }
+    }
+}
 /**
  * Check if a directory is a valid module
  */
@@ -76,11 +130,15 @@ function isValidModule(path) {
  * Find module within repository
  */
 function findModuleInRepo(repoRoot, modulePath) {
-    const possiblePaths = [
-        join(repoRoot, modulePath),
-        join(repoRoot, 'cognitive', 'modules', modulePath),
-        join(repoRoot, 'modules', modulePath),
+    const candidatePaths = [
+        resolve(repoRoot, modulePath),
+        resolve(repoRoot, 'cognitive', 'modules', modulePath),
+        resolve(repoRoot, 'modules', modulePath),
     ];
+    const possiblePaths = candidatePaths.filter((p) => isPathWithinRoot(repoRoot, p));
+    if (possiblePaths.length === 0) {
+        throw new Error(`Invalid module path (outside repository root): ${modulePath}`);
+    }
     for (const p of possiblePaths) {
         if (existsSync(p) && isValidModule(p)) {
             return p;
@@ -97,7 +155,11 @@ function copyDir(src, dest) {
     for (const entry of readdirSync(src)) {
         const srcPath = join(src, entry);
         const destPath = join(dest, entry);
-        if (statSync(srcPath).isDirectory()) {
+        const st = lstatSync(srcPath);
+        if (st.isSymbolicLink()) {
+            throw new Error(`Refusing to install module containing symlink: ${srcPath}`);
+        }
+        if (st.isDirectory()) {
             copyDir(srcPath, destPath);
         }
         else {
@@ -105,6 +167,74 @@ function copyDir(src, dest) {
         }
     }
 }
+async function downloadTarballWithSha256(url, outPath, maxBytes) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 10_000);
+    const hash = createHash('sha256');
+    let received = 0;
+    const fileStream = createWriteStream(outPath);
+    try {
+        const response = await fetch(url, {
+            headers: { 'User-Agent': 'cognitive-runtime/2.2' },
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to download tarball: ${response.status} ${response.statusText}`);
+        }
+        const contentLengthHeader = response.headers?.get?.('content-length');
+        if (contentLengthHeader) {
+            const contentLength = Number(contentLengthHeader);
+            if (!Number.isNaN(contentLength) && contentLength > maxBytes) {
+                throw new Error(`Tarball too large: ${contentLength} bytes (max ${maxBytes})`);
+            }
+        }
+        if (!response.body) {
+            throw new Error('Tarball response has no body');
+        }
+        const reader = response.body.getReader?.();
+        if (!reader) {
+            // Fallback: stream pipeline without incremental hash.
+            await pipeline(Readable.fromWeb(response.body), fileStream);
+            const content = await readFile(outPath);
+            return createHash('sha256').update(content).digest('hex');
+        }
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            if (value) {
+                received += value.byteLength;
+                if (received > maxBytes) {
+                    controller.abort();
+                    throw new Error(`Tarball too large: ${received} bytes (max ${maxBytes})`);
+                }
+                const chunk = Buffer.from(value);
+                hash.update(chunk);
+                if (!fileStream.write(chunk)) {
+                    await new Promise((resolve) => fileStream.once('drain', () => resolve()));
+                }
+            }
+        }
+        fileStream.end();
+        await finished(fileStream);
+        return hash.digest('hex');
+    }
+    catch (error) {
+        try {
+            fileStream.destroy();
+        }
+        catch {
+            // ignore
+        }
+        if (error instanceof Error && error.name === 'AbortError') {
+            throw new Error('Tarball download timed out after 10000ms');
+        }
+        throw error;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
 /**
  * Get module version from module.yaml or MODULE.md
  */
@@ -157,10 +287,219 @@ export async function getInstallInfo(moduleName) {
     const manifest = JSON.parse(content);
     return manifest[moduleName] || null;
 }
+/**
+ * Check if input looks like a GitHub URL or org/repo format
+ *
+ * GitHub formats:
+ * - https://github.com/org/repo
+ * - http://github.com/org/repo
+ * - github:org/repo
+ * - org/repo (shorthand, must be exactly two parts)
+ *
+ * NOT GitHub (registry module names):
+ * - code-reviewer
+ * - code-reviewer@1.0.0
+ * - my-module (no slash)
+ */
+function isGitHubSource(input) {
+    // URL formats
+    if (input.startsWith('http://') || input.startsWith('https://')) {
+        return true;
+    }
+    // github: prefix format
+    if (input.startsWith('github:')) {
+        return true;
+    }
+    // Contains github.com
+    if (input.includes('github.com')) {
+        return true;
+    }
+    // Shorthand format: org/repo (exactly two parts, no @ version suffix)
+    // Must match pattern like: owner/repo or owner/repo but NOT module@version
+    const shorthandMatch = input.match(/^([a-zA-Z0-9_.-]+)\/([a-zA-Z0-9_.-]+)$/);
+    if (shorthandMatch) {
+        // Additional check: if it contains @, it's likely a scoped npm package or versioned module
+        // But GitHub shorthand shouldn't have @ in the middle
+        return !input.includes('@');
+    }
+    return false;
+}
+/**
+ * Parse module name with optional version: "module-name@1.0.0"
+ */
+function parseModuleSpec(spec) {
+    const match = spec.match(/^([^@]+)(?:@(.+))?$/);
+    if (!match) {
+        return { name: spec };
+    }
+    return { name: match[1], version: match[2] };
+}
+/**
+ * Add a module from the registry
+ */
+export async function addFromRegistry(moduleSpec, ctx, options = {}) {
+    const { name: moduleName, version: requestedVersion } = parseModuleSpec(moduleSpec);
+    const { name: customName, registry: registryUrl } = options;
+    let tempDir;
+    try {
+        const client = new RegistryClient(registryUrl);
+        const moduleInfo = await client.getModule(moduleName);
+        if (!moduleInfo) {
+            return {
+                success: false,
+                error: `Module not found in registry: ${moduleName}\nUse 'cog search' to find available modules.`,
+            };
+        }
+        // Check if deprecated
+        if (moduleInfo.deprecated) {
+            console.error(`Warning: Module '${moduleName}' is deprecated.`);
+        }
+        // Get download info
+        const downloadInfo = await client.getDownloadUrl(moduleName);
+        if (downloadInfo.isGitHub && downloadInfo.githubInfo) {
+            const { org, repo, path, ref } = downloadInfo.githubInfo;
+            // Use addFromGitHub() directly (not add() to avoid recursion)
+            const result = await addFromGitHub(`${org}/${repo}`, ctx, {
+                module: path,
+                name: customName || moduleName,
+                tag: requestedVersion || ref,
+                branch: ref || 'main',
+            });
+            // If successful, update the install manifest to track registry info
+            if (result.success && result.data) {
+                const data = result.data;
+                const installName = data.name;
+                // Update manifest with registry info
+                const existingInfo = await getInstallInfo(installName);
+                if (existingInfo) {
+                    await recordInstall(installName, {
+                        ...existingInfo,
+                        registryModule: moduleName,
+                        registryUrl: registryUrl,
+                    });
+                }
+                else {
+                    // Fallback: create minimal install info if not found (shouldn't happen but safety first)
+                    await recordInstall(installName, {
+                        source: 'registry',
+                        githubUrl: `${org}/${repo}`,
+                        modulePath: path,
+                        version: data.version,
+                        installedAt: data.location || '',
+                        installedTime: new Date().toISOString(),
+                        registryModule: moduleName,
+                        registryUrl: registryUrl,
+                    });
+                }
+                // Update result to indicate registry source
+                result.data = {
+                    ...result.data,
+                    source: 'registry',
+                    registryModule: moduleName,
+                };
+            }
+            return result;
+        }
+        // Tarball sources: require checksum, verify, and extract safely.
+        if (!downloadInfo.url.startsWith('http')) {
+            return { success: false, error: `Unsupported registry download URL: ${downloadInfo.url}` };
+        }
+        if (!downloadInfo.checksum) {
+            return {
+                success: false,
+                error: `Registry tarball missing checksum (required for safe install): ${moduleName}`,
+            };
+        }
+        tempDir = join(tmpdir(), `cog-reg-${Date.now()}`);
+        mkdirSync(tempDir, { recursive: true });
+        const tarPath = join(tempDir, 'module.tar.gz');
+        const MAX_TARBALL_BYTES = 20 * 1024 * 1024; // 20MB
+        const actualSha256 = await downloadTarballWithSha256(downloadInfo.url, tarPath, MAX_TARBALL_BYTES);
+        const expected = downloadInfo.checksum;
+        const checksumMatch = expected.match(/^sha256:([a-f0-9]{64})$/);
+        if (!checksumMatch) {
+            throw new Error(`Unsupported checksum format (expected sha256:<64hex>): ${expected}`);
+        }
+        const expectedHash = checksumMatch[1];
+        if (actualSha256 !== expectedHash) {
+            throw new Error(`Checksum mismatch for ${moduleName}: expected ${expectedHash}, got ${actualSha256}`);
+        }
+        const extractedRoot = join(tempDir, 'pkg');
+        mkdirSync(extractedRoot, { recursive: true });
+        await extractTarGzFile(tarPath, extractedRoot, {
+            maxFiles: 5_000,
+            maxTotalBytes: 50 * 1024 * 1024,
+            maxSingleFileBytes: 20 * 1024 * 1024,
+            maxTarBytes: 100 * 1024 * 1024,
+        });
+        // Find module directory inside extractedRoot.
+        const rootNames = readdirSync(extractedRoot).filter((e) => e !== '__MACOSX' && e !== '.DS_Store');
+        const rootPaths = rootNames.map((e) => join(extractedRoot, e)).filter((p) => existsSync(p));
+        const rootDirs = rootPaths.filter((p) => statSync(p).isDirectory());
+        const rootFiles = rootPaths.filter((p) => !statSync(p).isDirectory());
+        if (rootDirs.length === 0) {
+            throw new Error('Tarball extraction produced no root directory');
+        }
+        if (rootDirs.length !== 1 || rootFiles.length > 0) {
+            throw new Error(`Tarball must contain exactly one module root directory and no other top-level entries. ` +
+                `dirs=${rootDirs.map((p) => basename(p)).join(',') || '(none)'} files=${rootFiles.map((p) => basename(p)).join(',') || '(none)'}`);
+        }
+        // Strict mode: require root dir itself to be a valid module.
+        const sourcePath = rootDirs[0];
+        if (!isValidModule(sourcePath)) {
+            throw new Error('Root directory in tarball is not a valid module');
+        }
+        const installName = (customName || moduleName);
+        const safeInstallName = assertSafeModuleName(installName);
+        const targetPath = resolveModuleTarget(safeInstallName);
+        if (existsSync(targetPath)) {
+            rmSync(targetPath, { recursive: true, force: true });
+        }
+        await mkdir(USER_MODULES_DIR, { recursive: true });
+        copyDir(sourcePath, targetPath);
+        const version = await getModuleVersion(sourcePath);
+        await recordInstall(safeInstallName, {
+            source: downloadInfo.url,
+            githubUrl: downloadInfo.url,
+            version,
+            installedAt: targetPath,
+            installedTime: new Date().toISOString(),
+            registryModule: moduleName,
+            registryUrl,
+        });
+        return {
+            success: true,
+            data: {
+                message: `Added: ${safeInstallName}${version ? ` v${version}` : ''} (registry tarball)`,
+                name: safeInstallName,
+                version,
+                location: targetPath,
+                source: 'registry',
+                registryModule: moduleName,
+            },
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+    finally {
+        if (tempDir) {
+            try {
+                rmSync(tempDir, { recursive: true, force: true });
+            }
+            catch {
+                // ignore
+            }
+        }
+    }
+}
 /**
  * Add a module from GitHub
  */
-export async function add(url, ctx, options = {}) {
+export async function addFromGitHub(url, ctx, options = {}) {
     const { org, repo, fullUrl } = parseGitHubUrl(url);
     const { module: modulePath, name, branch = 'main', tag } = options;
     // Determine ref (tag takes priority)
@@ -184,11 +523,11 @@ export async function add(url, ctx, options = {}) {
             sourcePath = repoRoot;
         }
         // Determine module name
-        moduleName = name || basename(sourcePath);
+        moduleName = name ? assertSafeModuleName(name) : basename(sourcePath);
         // Get version
         const version = await getModuleVersion(sourcePath);
         // Install to user modules dir
-        const targetPath = join(USER_MODULES_DIR, moduleName);
+        const targetPath = resolveModuleTarget(moduleName);
         // Remove existing
         if (existsSync(targetPath)) {
             rmSync(targetPath, { recursive: true, force: true });
@@ -208,8 +547,10 @@ export async function add(url, ctx, options = {}) {
             installedTime: new Date().toISOString(),
         });
         // Cleanup temp directory
-        const tempDir = repoRoot.split('/').slice(0, -1).join('/');
-        rmSync(tempDir, { recursive: true, force: true });
+        const tempDir = dirname(repoRoot);
+        if (tempDir && tempDir !== '/' && tempDir !== '.' && tempDir !== USER_MODULES_DIR) {
+            rmSync(tempDir, { recursive: true, force: true });
+        }
         return {
             success: true,
             data: {
@@ -217,13 +558,39 @@ export async function add(url, ctx, options = {}) {
                 name: moduleName,
                 version,
                 location: targetPath,
+                source: 'github',
             },
         };
     }
     catch (error) {
+        // Cleanup temp directory on error
+        if (repoRoot) {
+            try {
+                const tempDir = dirname(repoRoot);
+                if (tempDir && tempDir !== '/' && tempDir !== '.' && tempDir !== USER_MODULES_DIR) {
+                    rmSync(tempDir, { recursive: true, force: true });
+                }
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+        }
         return {
             success: false,
             error: error instanceof Error ? error.message : String(error),
         };
     }
 }
+/**
+ * Add a module from GitHub or Registry (auto-detect source)
+ */
+export async function add(source, ctx, options = {}) {
+    // Determine source type
+    if (isGitHubSource(source)) {
+        return addFromGitHub(source, ctx, options);
+    }
+    else {
+        // Treat as registry module name
+        return addFromRegistry(source, ctx, options);
+    }
+}

package/dist/commands/compose.js

@@ -8,14 +8,30 @@
  * - Iterative: A → (check) → A → ... → Done
  */
 import { findModule, getDefaultSearchPaths, executeComposition } from '../modules/index.js';
+import { ErrorCodes, attachContext, makeErrorEnvelope } from '../errors/index.js';
+function looksLikeCode(str) {
+    const codeIndicators = [
+        /^(def|function|class|const|let|var|import|export|public|private)\s/,
+        /[{};()]/,
+        /=>/,
+        /\.(py|js|ts|go|rs|java|cpp|c|rb)$/,
+    ];
+    return codeIndicators.some(re => re.test(str));
+}
 export async function compose(moduleName, ctx, options = {}) {
     const searchPaths = getDefaultSearchPaths(ctx.cwd);
     // Find module
     const module = await findModule(moduleName, searchPaths);
     if (!module) {
+        const errorEnvelope = attachContext(makeErrorEnvelope({
+            code: ErrorCodes.MODULE_NOT_FOUND,
+            message: `Module not found: ${moduleName}\nSearch paths: ${searchPaths.join(', ')}`,
+            suggestion: "Use 'cog list' to see installed modules or 'cog search' to find modules in registry",
+        }), { module: moduleName, provider: ctx.provider.name });
         return {
             success: false,
-            error: `Module not found: ${moduleName}\nSearch paths: ${searchPaths.join(', ')}`,
+            error: errorEnvelope.error.message,
+            data: errorEnvelope,
         };
     }
     try {
@@ -26,16 +42,26 @@ export async function compose(moduleName, ctx, options = {}) {
                 inputData = JSON.parse(options.input);
             }
             catch {
+                const errorEnvelope = attachContext(makeErrorEnvelope({
+                    code: ErrorCodes.INVALID_INPUT,
+                    message: `Invalid JSON input: ${options.input}`,
+                    suggestion: 'Ensure input is valid JSON format',
+                }), { module: moduleName, provider: ctx.provider.name });
                 return {
                     success: false,
-                    error: `Invalid JSON input: ${options.input}`,
+                    error: errorEnvelope.error.message,
+                    data: errorEnvelope,
                 };
             }
         }
         // Handle --args as text input
         if (options.args) {
-            inputData.query = options.args;
-            inputData.code = options.args;
+            if (looksLikeCode(options.args)) {
+                inputData.code = options.args;
+            }
+            else {
+                inputData.query = options.args;
+            }
         }
         // Execute composition
         const result = await executeComposition(moduleName, inputData, ctx.provider, {
@@ -56,11 +82,27 @@ export async function compose(moduleName, ctx, options = {}) {
             }
             console.error(`--- Total: ${result.totalTimeMs}ms ---`);
         }
+        if (!result.ok) {
+            const partialData = options.trace
+                ? { moduleResults: result.moduleResults, trace: result.trace }
+                : { moduleResults: result.moduleResults };
+            const errorEnvelope = attachContext(makeErrorEnvelope({
+                code: result.error?.code ?? ErrorCodes.INTERNAL_ERROR,
+                message: result.error?.message ?? 'Composition failed',
+                details: result.error?.module ? { module: result.error.module } : undefined,
+                partial_data: partialData,
+            }), { module: moduleName, provider: ctx.provider.name });
+            return {
+                success: false,
+                error: errorEnvelope.error.message,
+                data: errorEnvelope,
+            };
+        }
         // Return result
         if (options.trace) {
             // Include full result with trace
             return {
-                success: result.ok,
+                success: true,
                 data: {
                     ok: result.ok,
                     result: result.result,
@@ -73,33 +115,28 @@ export async function compose(moduleName, ctx, options = {}) {
         }
         else if (options.pretty) {
             return {
-                success: result.ok,
+                success: true,
                 data: result.result,
             };
         }
         else {
-            // For non-pretty mode, return data (success) or error (failure)
-            if (result.ok && result.result) {
-                return {
-                    success: true,
-                    data: result.result.data,
-                };
-            }
-            else {
-                return {
-                    success: false,
-                    error: result.error
-                        ? `${result.error.code}: ${result.error.message}`
-                        : 'Composition failed',
-                    data: result.moduleResults,
-                };
-            }
+            // Keep compose output consistent with run/pipe: always return full v2.2 envelope
+            return {
+                success: true,
+                data: result.result,
+            };
         }
     }
     catch (e) {
+        const errorEnvelope = attachContext(makeErrorEnvelope({
+            code: ErrorCodes.INTERNAL_ERROR,
+            message: e instanceof Error ? e.message : String(e),
+            recoverable: false,
+        }), { module: moduleName, provider: ctx.provider.name });
         return {
             success: false,
-            error: e instanceof Error ? e.message : String(e),
+            error: errorEnvelope.error.message,
+            data: errorEnvelope,
         };
     }
 }