@vxnus/siduri 0.1.8 → 0.1.10

package/dist/manifest.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateOrganManifest = validateOrganManifest;
+function validateOrganManifest(manifest, sourcePath) {
+    if (!manifest || typeof manifest !== 'object') {
+        throw new Error(`Invalid manifest at ${sourcePath || 'unknown'}: expected an object`);
+    }
+    const m = manifest;
+    if (!m.name || typeof m.name !== 'string' || !m.name.startsWith('@siduri-x/')) {
+        throw new Error(`Invalid manifest name in ${sourcePath || 'unknown'}: expected package name starting with @siduri-x/`);
+    }
+    if (!m.organType || typeof m.organType !== 'string') {
+        throw new Error(`Invalid manifest organType in ${sourcePath || m.name}`);
+    }
+    if (!m.version || typeof m.version !== 'string') {
+        throw new Error(`Invalid manifest version in ${sourcePath || m.name}`);
+    }
+    if (!m.displayName || typeof m.displayName !== 'string') {
+        throw new Error(`Invalid manifest displayName in ${sourcePath || m.name}`);
+    }
+    if (!m.entrypoint || typeof m.entrypoint !== 'string') {
+        throw new Error(`Invalid manifest entrypoint in ${sourcePath || m.name}`);
+    }
+    if (!m.factory || typeof m.factory !== 'string') {
+        throw new Error(`Invalid manifest factory in ${sourcePath || m.name}`);
+    }
+    if (!m.configKey || typeof m.configKey !== 'string') {
+        throw new Error(`Invalid manifest configKey in ${sourcePath || m.name}`);
+    }
+    if (!m.configSchema || typeof m.configSchema !== 'object') {
+        throw new Error(`Invalid manifest configSchema in ${sourcePath || m.name}`);
+    }
+    if (!Array.isArray(m.environment)) {
+        throw new Error(`Invalid manifest environment in ${sourcePath || m.name}: expected array`);
+    }
+    if (!Array.isArray(m.services)) {
+        throw new Error(`Invalid manifest services in ${sourcePath || m.name}: expected array`);
+    }
+    return m;
+}

package/dist/providers/knowledge-hub.d.ts

@@ -0,0 +1,37 @@
+export interface KnowledgeHubCapabilities {
+    search?: boolean;
+    retrieval?: boolean;
+    contextInjection?: boolean;
+    semanticSearch?: boolean;
+    lexicalSearch?: boolean;
+    [key: string]: unknown;
+}
+export interface KnowledgeHubManifest {
+    name: string;
+    displayName?: string;
+    publisher?: string;
+    package?: string;
+    version: string;
+    description?: string;
+    capabilities?: KnowledgeHubCapabilities | string[];
+    distribution?: {
+        kind?: string;
+        url?: string;
+    };
+    source?: string;
+    environment?: Array<{
+        name: string;
+        required?: boolean;
+        description?: string;
+    }>;
+}
+export declare const KNOWN_KNOWLEDGE_PACKS: Record<string, KnowledgeHubManifest>;
+export declare function validateKnowledgeManifest(raw: unknown, packId?: string): KnowledgeHubManifest;
+export declare function extractCapabilitiesList(capabilities?: KnowledgeHubCapabilities | string[]): string[];
+export declare class KnowledgeHubClient {
+    private registryUrl;
+    private timeoutMs;
+    constructor(registryUrl?: string, timeoutMs?: number);
+    resolveProvider(packId: string): Promise<KnowledgeHubManifest>;
+}
+export declare function displayKnowledgeProviderSummary(manifest: KnowledgeHubManifest, packId: string): void;

package/dist/providers/knowledge-hub.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KnowledgeHubClient = exports.KNOWN_KNOWLEDGE_PACKS = void 0;
+exports.validateKnowledgeManifest = validateKnowledgeManifest;
+exports.extractCapabilitiesList = extractCapabilitiesList;
+exports.displayKnowledgeProviderSummary = displayKnowledgeProviderSummary;
+exports.KNOWN_KNOWLEDGE_PACKS = {
+    '@vxnus/e-teyvat': {
+        name: 'e-teyvat',
+        displayName: 'E Teyvat',
+        publisher: 'vxnus',
+        package: '@vxnus/e-teyvat',
+        version: '1.2.0',
+        description: 'Teyvat knowledge provider for Siduri.',
+        capabilities: ['Search', 'Retrieval', 'Context injection'],
+        distribution: {
+            kind: 'provider',
+            url: 'https://teyvat.e.vxnus.xyz',
+        },
+        source: 'E Knowledge Hub',
+    },
+};
+function validateKnowledgeManifest(raw, packId) {
+    if (!raw || typeof raw !== 'object') {
+        throw new Error(`Invalid knowledge manifest: expected object.`);
+    }
+    const m = raw;
+    if (!m.name || typeof m.name !== 'string') {
+        throw new Error(`Invalid knowledge manifest: missing 'name' field.`);
+    }
+    if (!m.version || typeof m.version !== 'string') {
+        throw new Error(`Invalid knowledge manifest: missing 'version' field.`);
+    }
+    return {
+        name: m.name,
+        displayName: m.displayName || m.name,
+        publisher: m.publisher,
+        package: m.package || packId || m.name,
+        version: m.version,
+        description: m.description || 'Knowledge pack provider',
+        capabilities: m.capabilities || ['Search', 'Retrieval'],
+        distribution: m.distribution,
+        source: m.source || 'E Knowledge Hub',
+        environment: m.environment || [],
+    };
+}
+function extractCapabilitiesList(capabilities) {
+    if (!capabilities) {
+        return ['Search', 'Retrieval'];
+    }
+    if (Array.isArray(capabilities)) {
+        return capabilities.map((c) => String(c));
+    }
+    const result = [];
+    if (capabilities.lexicalSearch || capabilities.search)
+        result.push('Search');
+    result.push('Retrieval');
+    if (capabilities.contextInjection)
+        result.push('Context injection');
+    if (capabilities.semanticSearch)
+        result.push('Semantic search');
+    if (capabilities.structuredEntities)
+        result.push('Structured entities');
+    if (capabilities.relations)
+        result.push('Entity relations');
+    if (capabilities.revisions)
+        result.push('Content revisions');
+    for (const [key, val] of Object.entries(capabilities)) {
+        if (val === true && !['search', 'retrieval', 'contextInjection', 'semanticSearch', 'lexicalSearch', 'structuredEntities', 'relations', 'revisions'].includes(key)) {
+            result.push(key);
+        }
+    }
+    return result.length > 0 ? result : ['Search', 'Retrieval'];
+}
+class KnowledgeHubClient {
+    registryUrl;
+    timeoutMs;
+    constructor(registryUrl = 'https://e.vxnus.xyz/api/v1/knowledge', timeoutMs = 5000) {
+        this.registryUrl = registryUrl.replace(/\/+$/, '');
+        this.timeoutMs = timeoutMs;
+    }
+    async resolveProvider(packId) {
+        const trimmed = packId.trim();
+        const match = trimmed.match(/^@([^/]+)\/([^/]+)$/);
+        if (!match) {
+            throw new Error(`Invalid package ID format "${packId}". Expected format: @publisher/name (e.g. @vxnus/e-teyvat)`);
+        }
+        const publisher = match[1];
+        const name = match[2];
+        const url = `${this.registryUrl}/${encodeURIComponent(publisher)}/${encodeURIComponent(name)}`;
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+        try {
+            const response = await fetch(url, {
+                method: 'GET',
+                headers: { Accept: 'application/json' },
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                // Check offline/built-in catalog fallback for known pack IDs
+                if (exports.KNOWN_KNOWLEDGE_PACKS[trimmed]) {
+                    return exports.KNOWN_KNOWLEDGE_PACKS[trimmed];
+                }
+                throw new Error(`HTTP ${response.status}: ${response.statusText} for ${packId}`);
+            }
+            const body = await response.json();
+            return validateKnowledgeManifest(body, trimmed);
+        }
+        catch (err) {
+            // If network fails and known pack exists, use fallback
+            if (exports.KNOWN_KNOWLEDGE_PACKS[trimmed]) {
+                return exports.KNOWN_KNOWLEDGE_PACKS[trimmed];
+            }
+            throw new Error(`Failed to resolve package "${packId}" from E Knowledge Hub: ${err.message}`);
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+}
+exports.KnowledgeHubClient = KnowledgeHubClient;
+function displayKnowledgeProviderSummary(manifest, packId) {
+    const cyan = '\u001b[36m';
+    const dim = '\u001b[2m';
+    const reset = '\u001b[0m';
+    console.log(`\n${cyan}── Knowledge Provider ────────────────────────${reset}\n`);
+    console.log(`  ${dim}Name:${reset}        ${manifest.displayName || manifest.name}`);
+    console.log(`  ${dim}Package:${reset}     ${packId}`);
+    console.log(`  ${dim}Version:${reset}     ${manifest.version}`);
+    if (manifest.description) {
+        console.log(`\n  ${dim}Description:${reset}`);
+        console.log(`  ${manifest.description}`);
+    }
+    const caps = extractCapabilitiesList(manifest.capabilities);
+    console.log(`\n  ${dim}Capabilities:${reset}`);
+    for (const cap of caps) {
+        console.log(`    • ${cap}`);
+    }
+    console.log(`\n  ${dim}Source:${reset}`);
+    console.log(`    ${manifest.source || 'E Knowledge Hub'}\n`);
+}

package/dist/providers/openrouter.d.ts

@@ -0,0 +1,32 @@
+export interface ModelOption {
+    id: string;
+    name: string;
+    description?: string;
+    contextLength?: number;
+}
+export interface ModelProvider {
+    listModels(): Promise<ModelOption[]>;
+}
+export declare const CURATED_OPENROUTER_MODELS: ModelOption[];
+export declare class OpenRouterModelProvider implements ModelProvider {
+    private apiUrl;
+    private timeoutMs;
+    constructor(apiUrl?: string, timeoutMs?: number);
+    listModels(): Promise<ModelOption[]>;
+}
+export type ModelSelectionResult = {
+    type: 'selected';
+    modelId: string;
+    modelName: string;
+} | {
+    type: 'manual';
+    modelId: string;
+} | {
+    type: 'switch_provider';
+} | {
+    type: 'cancel';
+};
+/**
+ * Interactive model selector with search, pagination, and robust error recovery.
+ */
+export declare function promptOpenRouterModelSelection(provider?: ModelProvider): Promise<ModelSelectionResult>;

package/dist/providers/openrouter.js

@@ -0,0 +1,201 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenRouterModelProvider = exports.CURATED_OPENROUTER_MODELS = void 0;
+exports.promptOpenRouterModelSelection = promptOpenRouterModelSelection;
+const inquirer_1 = __importDefault(require("inquirer"));
+exports.CURATED_OPENROUTER_MODELS = [
+    { id: 'openai/gpt-4o-mini', name: 'OpenAI: GPT-4o Mini', description: 'Fast, lightweight intelligence' },
+    { id: 'openai/gpt-4o', name: 'OpenAI: GPT-4o', description: 'Flagship multimodal intelligence' },
+    { id: 'anthropic/claude-3.5-sonnet', name: 'Anthropic: Claude 3.5 Sonnet', description: 'State-of-the-art reasoning and coding' },
+    { id: 'anthropic/claude-3-haiku', name: 'Anthropic: Claude 3 Haiku', description: 'Fast and compact' },
+    { id: 'google/gemini-2.0-flash-001', name: 'Google: Gemini 2.0 Flash', description: 'Next-gen speed and multimodal capabilities' },
+    { id: 'meta-llama/llama-3.3-70b-instruct', name: 'Meta: Llama 3.3 70B Instruct', description: 'High capability open weights model' },
+    { id: 'deepseek/deepseek-chat', name: 'DeepSeek: DeepSeek V3', description: 'Advanced conversational and coding model' },
+    { id: 'deepseek/deepseek-r1', name: 'DeepSeek: DeepSeek R1', description: 'Advanced reasoning model' },
+    { id: 'mistralai/mistral-large', name: 'Mistral: Mistral Large', description: 'Top-tier reasoning and multilingual model' },
+];
+class OpenRouterModelProvider {
+    apiUrl;
+    timeoutMs;
+    constructor(apiUrl = 'https://openrouter.ai/api/v1/models', timeoutMs = 6000) {
+        this.apiUrl = apiUrl;
+        this.timeoutMs = timeoutMs;
+    }
+    async listModels() {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+        try {
+            const response = await fetch(this.apiUrl, {
+                method: 'GET',
+                headers: {
+                    Accept: 'application/json',
+                    'User-Agent': 'Siduri-CLI/1.0',
+                },
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            const body = (await response.json());
+            if (!body.data || !Array.isArray(body.data) || body.data.length === 0) {
+                throw new Error('Received empty or invalid model list from OpenRouter API.');
+            }
+            return body.data.map((m) => ({
+                id: m.id,
+                name: m.name || m.id,
+                description: m.description,
+                contextLength: m.context_length,
+            }));
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+}
+exports.OpenRouterModelProvider = OpenRouterModelProvider;
+/**
+ * Interactive model selector with search, pagination, and robust error recovery.
+ */
+async function promptOpenRouterModelSelection(provider = new OpenRouterModelProvider()) {
+    let models = [];
+    let fetchFailed = false;
+    let fetchError = '';
+    // 1. Fetch models dynamically
+    try {
+        process.stdout.write('\u001b[2mFetching OpenRouter models...\u001b[0m');
+        models = await provider.listModels();
+        process.stdout.write('\r\u001b[32m✓\u001b[0m Fetched OpenRouter models catalog\n');
+    }
+    catch (err) {
+        fetchFailed = true;
+        fetchError = err.message || String(err);
+        process.stdout.write('\r\u001b[33m!\u001b[0m Unable to fetch OpenRouter models.\n');
+    }
+    // 2. Handle failure if API is unreachable
+    if (fetchFailed || models.length === 0) {
+        console.log(`\u001b[33mReason:\u001b[0m ${fetchError || 'No models returned.'}\n`);
+        const { failureAction } = await inquirer_1.default.prompt({
+            type: 'list',
+            name: 'failureAction',
+            message: 'What would you like to do?',
+            choices: [
+                { name: 'Retry fetching models', value: 'retry' },
+                { name: 'Use curated standard models', value: 'curated' },
+                { name: 'Enter model ID manually', value: 'manual' },
+                { name: 'Choose another Brain provider', value: 'switch_provider' },
+                { name: 'Cancel', value: 'cancel' },
+            ],
+        });
+        if (failureAction === 'retry') {
+            return promptOpenRouterModelSelection(provider);
+        }
+        if (failureAction === 'curated') {
+            models = exports.CURATED_OPENROUTER_MODELS;
+        }
+        else if (failureAction === 'manual') {
+            const { manualId } = await inquirer_1.default.prompt({
+                type: 'input',
+                name: 'manualId',
+                message: 'Model ID (e.g. openai/gpt-4o-mini):',
+                default: 'openai/gpt-4o-mini',
+                validate: (val) => val.trim().length > 0 || 'Please enter a model ID.',
+            });
+            return { type: 'manual', modelId: manualId.trim() };
+        }
+        else if (failureAction === 'switch_provider') {
+            return { type: 'switch_provider' };
+        }
+        else {
+            return { type: 'cancel' };
+        }
+    }
+    // 3. Selection flow with filtering
+    let currentSearch = '';
+    while (true) {
+        let filtered = models;
+        if (currentSearch.trim()) {
+            const q = currentSearch.toLowerCase();
+            filtered = models.filter((m) => m.name.toLowerCase().includes(q) || m.id.toLowerCase().includes(q));
+        }
+        const choices = [];
+        // Search action at top
+        if (currentSearch) {
+            choices.push({
+                name: `\u001b[36m⌕ Clear filter (currently: "${currentSearch}") [${filtered.length} matches]\u001b[0m`,
+                value: '__CLEAR_FILTER__',
+            });
+        }
+        else {
+            choices.push({
+                name: `\u001b[36m⌕ Search / Filter models by keyword...\u001b[0m`,
+                value: '__FILTER__',
+            });
+        }
+        choices.push(new inquirer_1.default.Separator('── Models ──'));
+        if (filtered.length === 0) {
+            choices.push({
+                name: `\u001b[33mNo models matched "${currentSearch}". Search again or enter manually.\u001b[0m`,
+                value: '__FILTER__',
+            });
+        }
+        else {
+            // Limit to max 40 items displayed per page to prevent UI overload
+            const displayList = filtered.slice(0, 40);
+            for (const m of displayList) {
+                const idLabel = m.name !== m.id ? ` \u001b[2m(${m.id})\u001b[0m` : '';
+                choices.push({
+                    name: `${m.name}${idLabel}`,
+                    value: m.id,
+                });
+            }
+            if (filtered.length > 40) {
+                choices.push(new inquirer_1.default.Separator(`... and ${filtered.length - 40} more (use search to refine)`));
+            }
+        }
+        choices.push(new inquirer_1.default.Separator('── Other Options ──'));
+        choices.push({ name: 'Enter model ID manually', value: '__MANUAL__' });
+        choices.push({ name: 'Choose another Brain provider', value: '__SWITCH__' });
+        const { selectedValue } = await inquirer_1.default.prompt({
+            type: 'list',
+            name: 'selectedValue',
+            message: currentSearch ? `Select model (filtered by "${currentSearch}"):` : 'Select model:',
+            pageSize: 15,
+            choices,
+        });
+        if (selectedValue === '__FILTER__') {
+            const { query } = await inquirer_1.default.prompt({
+                type: 'input',
+                name: 'query',
+                message: 'Search models (e.g. claude, gpt, gemini, llama):',
+            });
+            currentSearch = query.trim();
+            continue;
+        }
+        if (selectedValue === '__CLEAR_FILTER__') {
+            currentSearch = '';
+            continue;
+        }
+        if (selectedValue === '__MANUAL__') {
+            const { manualId } = await inquirer_1.default.prompt({
+                type: 'input',
+                name: 'manualId',
+                message: 'Model ID (e.g. openai/gpt-4o-mini):',
+                default: 'openai/gpt-4o-mini',
+                validate: (val) => val.trim().length > 0 || 'Please enter a model ID.',
+            });
+            return { type: 'manual', modelId: manualId.trim() };
+        }
+        if (selectedValue === '__SWITCH__') {
+            return { type: 'switch_provider' };
+        }
+        const matchedModel = models.find((m) => m.id === selectedValue);
+        return {
+            type: 'selected',
+            modelId: selectedValue,
+            modelName: matchedModel?.name || selectedValue,
+        };
+    }
+}

package/dist/release-check.d.ts

@@ -0,0 +1,9 @@
+export interface ReleaseCheckReport {
+    packagesChecked: number;
+    tarballsInspected: number;
+    manifestsValidated: number;
+    cleanMachinePassed: boolean;
+    passed: boolean;
+    errors: string[];
+}
+export declare function runReleaseCheck(repoRoot?: string): ReleaseCheckReport;

package/dist/release-check.js

@@ -0,0 +1,133 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runReleaseCheck = runReleaseCheck;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+function run(cmd, cwd) {
+    return (0, node_child_process_1.execSync)(cmd, { cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] });
+}
+function runReleaseCheck(repoRoot = node_path_1.default.resolve(__dirname, '../..')) {
+    const errors = [];
+    const tempPackDir = node_path_1.default.resolve(repoRoot, 'cli/temp-release-check-packs');
+    if (node_fs_1.default.existsSync(tempPackDir))
+        node_fs_1.default.rmSync(tempPackDir, { recursive: true, force: true });
+    node_fs_1.default.mkdirSync(tempPackDir, { recursive: true });
+    const getPkgVer = (dir) => JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.resolve(repoRoot, dir, 'package.json'), 'utf8')).version;
+    const canonicalPackages = [
+        { name: '@siduri-x/core', dir: 'packages/core', isOrgan: false, tarName: `siduri-x-core-${getPkgVer('packages/core')}.tgz` },
+        { name: '@siduri-x/brain', dir: 'packages/organs/brain', isOrgan: true, tarName: `siduri-x-brain-${getPkgVer('packages/organs/brain')}.tgz` },
+        { name: '@siduri-x/memory', dir: 'packages/organs/memory', isOrgan: true, tarName: `siduri-x-memory-${getPkgVer('packages/organs/memory')}.tgz` },
+        { name: '@siduri-x/knowledge', dir: 'packages/organs/knowledge', isOrgan: true, tarName: `siduri-x-knowledge-${getPkgVer('packages/organs/knowledge')}.tgz` },
+        { name: '@siduri-x/behavior', dir: 'packages/organs/behavior', isOrgan: true, tarName: `siduri-x-behavior-${getPkgVer('packages/organs/behavior')}.tgz` },
+        { name: '@siduri-x/ear', dir: 'packages/organs/ear', isOrgan: true, tarName: `siduri-x-ear-${getPkgVer('packages/organs/ear')}.tgz` },
+        { name: '@siduri-x/vision', dir: 'packages/organs/vision', isOrgan: true, tarName: `siduri-x-vision-${getPkgVer('packages/organs/vision')}.tgz` },
+        { name: '@siduri-x/hands', dir: 'packages/organs/hands', isOrgan: true, tarName: `siduri-x-hands-${getPkgVer('packages/organs/hands')}.tgz` },
+        { name: '@siduri-x/body', dir: 'packages/organs/body', isOrgan: true, tarName: `siduri-x-body-${getPkgVer('packages/organs/body')}.tgz` },
+        { name: '@siduri-x/voice', dir: 'packages/organs/voice', isOrgan: true, tarName: `siduri-x-voice-${getPkgVer('packages/organs/voice')}.tgz` },
+        { name: '@siduri-x/mouth', dir: 'packages/organs/mouth', isOrgan: true, tarName: `siduri-x-mouth-${getPkgVer('packages/organs/mouth')}.tgz` },
+        { name: '@siduri-x/observation', dir: 'packages/organs/observation', isOrgan: true, tarName: `siduri-x-observation-${getPkgVer('packages/organs/observation')}.tgz` },
+        { name: '@vxnus/siduri', dir: 'cli', isOrgan: false, tarName: `vxnus-siduri-${getPkgVer('cli')}.tgz` },
+    ];
+    let packagesChecked = 0;
+    let tarballsInspected = 0;
+    let manifestsValidated = 0;
+    try {
+        // 1. Pack each package
+        for (const pkg of canonicalPackages) {
+            packagesChecked++;
+            try {
+                run(`pnpm --filter ${pkg.name} pack --pack-destination ${tempPackDir}`, repoRoot);
+            }
+            catch (err) {
+                errors.push(`Failed to pack ${pkg.name}: ${err.message}`);
+                continue;
+            }
+            const tarPath = node_path_1.default.join(tempPackDir, pkg.tarName);
+            if (!node_fs_1.default.existsSync(tarPath)) {
+                errors.push(`Tarball not found for ${pkg.name} at ${tarPath}`);
+                continue;
+            }
+            tarballsInspected++;
+            // Inspect tarball package.json
+            const pkgJsonRaw = run(`tar -xzf ${tarPath} -O package/package.json`, repoRoot);
+            const pkgJson = JSON.parse(pkgJsonRaw);
+            // Check package metadata
+            if (!pkgJson.name)
+                errors.push(`${pkg.name}: missing 'name'`);
+            if (!pkgJson.version)
+                errors.push(`${pkg.name}: missing 'version'`);
+            if (!pkgJson.description)
+                errors.push(`${pkg.name}: missing 'description'`);
+            if (!pkgJson.license)
+                errors.push(`${pkg.name}: missing 'license'`);
+            if (!pkgJson.engines || !pkgJson.engines.node)
+                errors.push(`${pkg.name}: missing 'engines.node'`);
+            // Check for zero workspace: or link: dependencies
+            const deps = { ...(pkgJson.dependencies || {}), ...(pkgJson.peerDependencies || {}) };
+            for (const [dep, ver] of Object.entries(deps)) {
+                if (typeof ver === 'string') {
+                    if (ver.startsWith('workspace:'))
+                        errors.push(`${pkg.name}: contains workspace dependency on ${dep}`);
+                    if (ver.startsWith('link:'))
+                        errors.push(`${pkg.name}: contains link: dependency on ${dep}`);
+                    if (ver.includes('../'))
+                        errors.push(`${pkg.name}: contains relative path on ${dep}`);
+                }
+            }
+            // Check tarball contents
+            const listing = run(`tar -tzf ${tarPath}`, repoRoot).split('\n');
+            if (pkg.isOrgan) {
+                if (!listing.some((l) => l.includes('package/organ-manifest.json'))) {
+                    errors.push(`${pkg.name}: organ-manifest.json missing in tarball`);
+                }
+                else {
+                    manifestsValidated++;
+                }
+            }
+            if (pkg.name === '@siduri-x/memory') {
+                if (!listing.some((l) => l.includes('package/migrations/001_initial_schema.sql'))) {
+                    errors.push(`${pkg.name}: migrations/001_initial_schema.sql missing in tarball`);
+                }
+            }
+            if (pkg.name === '@vxnus/siduri') {
+                if (!pkgJson.bin || !pkgJson.bin.siduri) {
+                    errors.push(`${pkg.name}: bin.siduri field missing in package.json`);
+                }
+            }
+        }
+    }
+    finally {
+        if (node_fs_1.default.existsSync(tempPackDir))
+            node_fs_1.default.rmSync(tempPackDir, { recursive: true, force: true });
+    }
+    return {
+        packagesChecked,
+        tarballsInspected,
+        manifestsValidated,
+        cleanMachinePassed: errors.length === 0,
+        passed: errors.length === 0,
+        errors,
+    };
+}
+if (require.main === module) {
+    console.log('Running release:check verification...');
+    const report = runReleaseCheck();
+    console.log(`Packages checked: ${report.packagesChecked}`);
+    console.log(`Tarballs inspected: ${report.tarballsInspected}`);
+    console.log(`Manifests validated: ${report.manifestsValidated}`);
+    if (report.passed) {
+        console.log('✓ release:check PASS: All packages meet canonical release invariants.');
+        process.exitCode = 0;
+    }
+    else {
+        console.error('✗ release:check FAIL:');
+        for (const err of report.errors) {
+            console.error(`  - ${err}`);
+        }
+        process.exitCode = 1;
+    }
+}

package/dist/runtime-parity.test.d.ts

@@ -0,0 +1 @@
+export {};