fraim-framework 2.0.33 → 2.0.35

package/bin/fraim.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+/**
+ * FRAIM CLI Entry Point
+ * This wrapper loads and executes the compiled CLI from dist/
+ */
+
+require('../dist/src/cli/fraim.js');

package/dist/src/cli/commands/sync.js

@@ -60,97 +60,92 @@ const runSync = async (options) => {
     const existingDigest = fs_1.default.existsSync(digestPath) ? fs_1.default.readFileSync(digestPath, 'utf8') : '';
     if (currentDigest === existingDigest && !options.force) {
         console.log(chalk_1.default.green('✅ Workflows are already in sync.'));
-        return;
     }
-    const registryWorkflowsPath = path_1.default.join(registryPath, 'workflows');
-    if (!fs_1.default.existsSync(registryWorkflowsPath)) {
-        console.log(chalk_1.default.yellow('⚠️ No workflows found in registry.'));
-        return;
-    }
-    // Get all workflows from registry (recursive)
-    const getFiles = (dir) => {
-        const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
-        const files = entries
-            .filter(e => !e.isDirectory() && e.name.endsWith('.md'))
-            .map(e => path_1.default.join(dir, e.name));
-        const folders = entries.filter(e => e.isDirectory());
-        for (const folder of folders) {
-            files.push(...getFiles(path_1.default.join(dir, folder.name)));
-        }
-        return files;
-    };
-    const registryFiles = getFiles(registryWorkflowsPath);
-    const generatedStubs = [];
-    for (const file of registryFiles) {
-        const content = fs_1.default.readFileSync(file, 'utf8');
-        const { intent, principles } = (0, stub_generator_1.parseRegistryWorkflow)(content);
-        const fileName = path_1.default.basename(file);
-        const workflowName = fileName.replace('.md', '');
-        // Calculate relative path from registry/workflows to preserve structure
-        const relativePath = path_1.default.relative(registryWorkflowsPath, file);
-        const relativeDir = path_1.default.dirname(relativePath);
-        // Ensure target directory exists
-        const targetDir = path_1.default.join(workflowsDir, relativeDir);
-        if (!fs_1.default.existsSync(targetDir)) {
-            fs_1.default.mkdirSync(targetDir, { recursive: true });
-        }
-        const stubContent = (0, stub_generator_1.generateWorkflowStub)(workflowName, file, intent, principles);
-        const stubPath = path_1.default.join(targetDir, fileName);
-        fs_1.default.writeFileSync(stubPath, stubContent);
-        generatedStubs.push(relativePath); // Store relative path for cleanup tracking
-        console.log(chalk_1.default.gray(`  + ${workflowName} (${relativeDir === '.' ? 'root' : relativeDir})`));
-    }
-    // Cleanup stubs that no longer exist in registry
-    // Cleanup stubs that no longer exist in registry
-    // Helper to get all local stubs recursively
-    const getLocalStubs = (dir) => {
-        if (!fs_1.default.existsSync(dir))
-            return [];
-        const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
-        const files = entries
-            .filter(e => !e.isDirectory() && e.name.endsWith('.md'))
-            .map(e => path_1.default.relative(workflowsDir, path_1.default.join(dir, e.name)));
-        const folders = entries.filter(e => e.isDirectory());
-        for (const folder of folders) {
-            files.push(...getLocalStubs(path_1.default.join(dir, folder.name)));
+    else {
+        const registryWorkflowsPath = path_1.default.join(registryPath, 'workflows');
+        if (!fs_1.default.existsSync(registryWorkflowsPath)) {
+            console.log(chalk_1.default.yellow('⚠️ No workflows found in registry.'));
         }
-        return files;
-    };
-    const localStubs = getLocalStubs(workflowsDir);
-    for (const stub of localStubs) {
-        // standardise path separators for comparison
-        const normalizedStub = stub.replace(/\\/g, '/');
-        const normalizedGenerated = generatedStubs.map(s => s.replace(/\\/g, '/'));
-        if (!normalizedGenerated.includes(normalizedStub)) {
-            fs_1.default.unlinkSync(path_1.default.join(workflowsDir, stub));
-            console.log(chalk_1.default.yellow(`  - ${stub} (removed from registry)`));
-            // Cleanup empty directories
-            try {
-                const dir = path_1.default.dirname(path_1.default.join(workflowsDir, stub));
-                if (fs_1.default.readdirSync(dir).length === 0) {
-                    fs_1.default.rmdirSync(dir);
+        else {
+            // Get all workflows from registry (recursive)
+            const getFiles = (dir) => {
+                const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+                const files = entries
+                    .filter(e => !e.isDirectory() && e.name.endsWith('.md'))
+                    .map(e => path_1.default.join(dir, e.name));
+                const folders = entries.filter(e => e.isDirectory());
+                for (const folder of folders) {
+                    files.push(...getFiles(path_1.default.join(dir, folder.name)));
+                }
+                return files;
+            };
+            const registryFiles = getFiles(registryWorkflowsPath);
+            const generatedStubs = [];
+            for (const file of registryFiles) {
+                const content = fs_1.default.readFileSync(file, 'utf8');
+                const { intent, principles } = (0, stub_generator_1.parseRegistryWorkflow)(content);
+                const fileName = path_1.default.basename(file);
+                const workflowName = fileName.replace('.md', '');
+                // Calculate relative path from registry/workflows to preserve structure
+                const relativePath = path_1.default.relative(registryWorkflowsPath, file);
+                const relativeDir = path_1.default.dirname(relativePath);
+                // Ensure target directory exists
+                const targetDir = path_1.default.join(workflowsDir, relativeDir);
+                if (!fs_1.default.existsSync(targetDir)) {
+                    fs_1.default.mkdirSync(targetDir, { recursive: true });
                 }
+                const stubContent = (0, stub_generator_1.generateWorkflowStub)(workflowName, file, intent, principles);
+                const stubPath = path_1.default.join(targetDir, fileName);
+                fs_1.default.writeFileSync(stubPath, stubContent);
+                generatedStubs.push(relativePath); // Store relative path for cleanup tracking
+                console.log(chalk_1.default.gray(`  + ${workflowName} (${relativeDir === '.' ? 'root' : relativeDir})`));
             }
-            catch (e) { }
+            // Cleanup stubs that no longer exist in registry
+            // Helper to get all local stubs recursively
+            const getLocalStubs = (dir) => {
+                if (!fs_1.default.existsSync(dir))
+                    return [];
+                const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+                const files = entries
+                    .filter(e => !e.isDirectory() && e.name.endsWith('.md'))
+                    .map(e => path_1.default.relative(workflowsDir, path_1.default.join(dir, e.name)));
+                const folders = entries.filter(e => e.isDirectory());
+                for (const folder of folders) {
+                    files.push(...getLocalStubs(path_1.default.join(dir, folder.name)));
+                }
+                return files;
+            };
+            const localStubs = getLocalStubs(workflowsDir);
+            for (const stub of localStubs) {
+                // standardise path separators for comparison
+                const normalizedStub = stub.replace(/\\/g, '/');
+                const normalizedGenerated = generatedStubs.map(s => s.replace(/\\/g, '/'));
+                if (!normalizedGenerated.includes(normalizedStub)) {
+                    fs_1.default.unlinkSync(path_1.default.join(workflowsDir, stub));
+                    console.log(chalk_1.default.yellow(`  - ${stub} (removed from registry)`));
+                    // Cleanup empty directories
+                    try {
+                        const dir = path_1.default.dirname(path_1.default.join(workflowsDir, stub));
+                        if (fs_1.default.readdirSync(dir).length === 0) {
+                            fs_1.default.rmdirSync(dir);
+                        }
+                    }
+                    catch (e) { }
+                }
+            }
+            fs_1.default.writeFileSync(digestPath, currentDigest);
+            console.log(chalk_1.default.green(`\n✅ Workflow sync complete. Generated ${generatedStubs.length} stubs.`));
         }
     }
-    fs_1.default.writeFileSync(digestPath, currentDigest);
-    console.log(chalk_1.default.green(`\n✅ Workflow sync complete. Generated ${generatedStubs.length} stubs.`));
-    // Sync scripts to user directory
+    // Always sync scripts, regardless of workflow sync status
     console.log(chalk_1.default.blue('\n🔄 Syncing FRAIM scripts to user directory...'));
     const syncResult = (0, script_sync_utils_1.syncScriptsToUserDirectory)(registryPath);
     const cleanedScriptCount = (0, script_sync_utils_1.cleanupObsoleteUserScripts)(registryPath);
     if (syncResult.synced > 0 || cleanedScriptCount > 0) {
-        console.log(chalk_1.default.green(`✅ Script sync complete. Updated ${syncResult.synced} self-contained scripts, removed ${cleanedScriptCount} obsolete scripts.`));
-        if (syncResult.ephemeral > 0) {
-            console.log(chalk_1.default.gray(`   ${syncResult.ephemeral} dependent scripts will use ephemeral execution.`));
-        }
+        console.log(chalk_1.default.green(`✅ Script sync complete. Updated ${syncResult.synced} scripts, removed ${cleanedScriptCount} obsolete scripts.`));
     }
     else {
         console.log(chalk_1.default.green('✅ Scripts are already in sync.'));
-        if (syncResult.ephemeral > 0) {
-            console.log(chalk_1.default.gray(`   ${syncResult.ephemeral} dependent scripts will use ephemeral execution.`));
-        }
     }
 };
 exports.runSync = runSync;

package/dist/src/utils/script-sync-utils.js

@@ -6,14 +6,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getUserFraimDir = getUserFraimDir;
 exports.getUserScriptsDir = getUserScriptsDir;
 exports.ensureUserFraimDirectories = ensureUserFraimDirectories;
-exports.isScriptSelfContained = isScriptSelfContained;
 exports.getRegistryScripts = getRegistryScripts;
 exports.copyScriptToUserDirectory = copyScriptToUserDirectory;
 exports.syncScriptsToUserDirectory = syncScriptsToUserDirectory;
 exports.cleanupObsoleteUserScripts = cleanupObsoleteUserScripts;
 exports.getUserScriptPath = getUserScriptPath;
 exports.userScriptExists = userScriptExists;
-exports.getDependentRegistryScripts = getDependentRegistryScripts;
 exports.validateUserScripts = validateUserScripts;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
@@ -46,60 +44,54 @@ function ensureUserFraimDirectories() {
     }
 }
 /**
- * Check if a script is self-contained (no relative imports to FRAIM source)
- */
-function isScriptSelfContained(scriptPath) {
-    // Shell scripts are always considered self-contained
-    if (scriptPath.endsWith('.sh')) {
-        return true;
-    }
-    // For TypeScript/JavaScript files, check for relative imports to src/
-    if (scriptPath.endsWith('.ts') || scriptPath.endsWith('.js')) {
-        try {
-            const content = fs_1.default.readFileSync(scriptPath, 'utf-8');
-            // Look for imports that reference ../../src/ or similar patterns
-            const hasRelativeImports = /import.*['"]\.\.\/.*src\//.test(content) ||
-                /require\(['"]\.\.\/.*src\//.test(content) ||
-                /from ['"]\.\.\/.*src\//.test(content);
-            return !hasRelativeImports;
-        }
-        catch (error) {
-            // If we can't read the file, assume it's not self-contained
-            return false;
-        }
-    }
-    return false;
-}
-/**
- * Get all self-contained script files from the registry
+ * Get all script files from the registry (recursively)
  */
 function getRegistryScripts(registryPath) {
     const scriptsPath = path_1.default.join(registryPath, 'scripts');
     if (!fs_1.default.existsSync(scriptsPath)) {
         return [];
     }
-    const entries = fs_1.default.readdirSync(scriptsPath, { withFileTypes: true });
-    const allScripts = entries
-        .filter(entry => entry.isFile() && (entry.name.endsWith('.sh') || entry.name.endsWith('.ts') || entry.name.endsWith('.js')))
-        .map(entry => path_1.default.join(scriptsPath, entry.name));
-    // Only return self-contained scripts
-    return allScripts.filter(scriptPath => isScriptSelfContained(scriptPath));
+    const getAllFiles = (dir, baseDir = dir) => {
+        const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+        let files = [];
+        for (const entry of entries) {
+            const fullPath = path_1.default.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                // Recursively get files from subdirectories
+                files = files.concat(getAllFiles(fullPath, baseDir));
+            }
+            else {
+                // Include all files (not just specific extensions)
+                files.push(fullPath);
+            }
+        }
+        return files;
+    };
+    return getAllFiles(scriptsPath);
 }
 /**
  * Copy a script file to the user scripts directory with proper permissions
+ * Preserves directory structure from registry/scripts/
  */
-function copyScriptToUserDirectory(sourcePath, scriptName) {
+function copyScriptToUserDirectory(sourcePath, registryScriptsPath) {
     const userScriptsDir = getUserScriptsDir();
-    const targetPath = path_1.default.join(userScriptsDir, scriptName);
+    // Calculate relative path from registry/scripts to preserve structure
+    const relativePath = path_1.default.relative(registryScriptsPath, sourcePath);
+    const targetPath = path_1.default.join(userScriptsDir, relativePath);
+    // Ensure target directory exists
+    const targetDir = path_1.default.dirname(targetPath);
+    if (!fs_1.default.existsSync(targetDir)) {
+        fs_1.default.mkdirSync(targetDir, { recursive: true });
+    }
     // Copy the file
     fs_1.default.copyFileSync(sourcePath, targetPath);
-    // Set executable permissions on Unix systems
-    if (process.platform !== 'win32' && scriptName.endsWith('.sh')) {
+    // Set executable permissions on Unix systems for shell scripts
+    if (process.platform !== 'win32' && sourcePath.endsWith('.sh')) {
         try {
             fs_1.default.chmodSync(targetPath, 0o755);
         }
         catch (error) {
-            console.warn(chalk_1.default.yellow(`⚠️ Could not set executable permissions for ${scriptName}`));
+            console.warn(chalk_1.default.yellow(`⚠️ Could not set executable permissions for ${relativePath}`));
         }
     }
 }
@@ -108,13 +100,13 @@ function copyScriptToUserDirectory(sourcePath, scriptName) {
  */
 function syncScriptsToUserDirectory(registryPath) {
     ensureUserFraimDirectories();
-    const selfContainedScripts = getRegistryScripts(registryPath);
-    const dependentScripts = getDependentRegistryScripts(registryPath);
+    const registryScriptsPath = path_1.default.join(registryPath, 'scripts');
+    const allScripts = getRegistryScripts(registryPath);
     let syncedCount = 0;
-    console.log(chalk_1.default.gray(`  Self-contained scripts (will be synced to ~/.fraim/scripts/):`));
-    for (const scriptPath of selfContainedScripts) {
-        const scriptName = path_1.default.basename(scriptPath);
-        const userScriptPath = path_1.default.join(getUserScriptsDir(), scriptName);
+    console.log(chalk_1.default.gray(`  Syncing all scripts to ~/.fraim/scripts/:`));
+    for (const scriptPath of allScripts) {
+        const relativePath = path_1.default.relative(registryScriptsPath, scriptPath);
+        const userScriptPath = path_1.default.join(getUserScriptsDir(), relativePath);
         try {
             // Check if script needs updating
             let needsUpdate = true;
@@ -124,26 +116,19 @@ function syncScriptsToUserDirectory(registryPath) {
                 needsUpdate = registryContent !== userContent;
             }
             if (needsUpdate) {
-                copyScriptToUserDirectory(scriptPath, scriptName);
+                copyScriptToUserDirectory(scriptPath, registryScriptsPath);
                 syncedCount++;
-                console.log(chalk_1.default.gray(`    + ${scriptName}`));
+                console.log(chalk_1.default.gray(`    + ${relativePath}`));
             }
             else {
-                console.log(chalk_1.default.gray(`    = ${scriptName} (up to date)`));
+                console.log(chalk_1.default.gray(`    = ${relativePath} (up to date)`));
             }
         }
         catch (error) {
-            console.warn(chalk_1.default.yellow(`⚠️ Could not sync script ${scriptName}: ${error}`));
+            console.warn(chalk_1.default.yellow(`⚠️ Could not sync script ${relativePath}: ${error}`));
         }
     }
-    if (dependentScripts.length > 0) {
-        console.log(chalk_1.default.gray(`  Dependent scripts (will use ephemeral execution):`));
-        for (const scriptPath of dependentScripts) {
-            const scriptName = path_1.default.basename(scriptPath);
-            console.log(chalk_1.default.gray(`    ~ ${scriptName} (has FRAIM dependencies)`));
-        }
-    }
-    return { synced: syncedCount, ephemeral: dependentScripts.length };
+    return { synced: syncedCount, ephemeral: 0 };
 }
 /**
  * Clean up scripts in user directory that no longer exist in registry
@@ -153,21 +138,49 @@ function cleanupObsoleteUserScripts(registryPath) {
     if (!fs_1.default.existsSync(userScriptsDir)) {
         return 0;
     }
+    const registryScriptsPath = path_1.default.join(registryPath, 'scripts');
     const registryScripts = getRegistryScripts(registryPath);
-    const registryScriptNames = registryScripts.map(scriptPath => path_1.default.basename(scriptPath));
-    const userScripts = fs_1.default.readdirSync(userScriptsDir)
-        .filter(file => file.endsWith('.sh') || file.endsWith('.ts') || file.endsWith('.js'));
+    const registryRelativePaths = registryScripts.map(scriptPath => path_1.default.relative(registryScriptsPath, scriptPath));
+    // Get all files in user scripts directory recursively
+    const getAllUserFiles = (dir, baseDir = dir) => {
+        if (!fs_1.default.existsSync(dir))
+            return [];
+        const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+        let files = [];
+        for (const entry of entries) {
+            const fullPath = path_1.default.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                files = files.concat(getAllUserFiles(fullPath, baseDir));
+            }
+            else {
+                files.push(path_1.default.relative(baseDir, fullPath));
+            }
+        }
+        return files;
+    };
+    const userFiles = getAllUserFiles(userScriptsDir);
     let cleanedCount = 0;
-    for (const userScript of userScripts) {
-        if (!registryScriptNames.includes(userScript)) {
+    for (const userFile of userFiles) {
+        // Normalize path separators for comparison
+        const normalizedUserFile = userFile.replace(/\\/g, '/');
+        const normalizedRegistry = registryRelativePaths.map(p => p.replace(/\\/g, '/'));
+        if (!normalizedRegistry.includes(normalizedUserFile)) {
             try {
-                const userScriptPath = path_1.default.join(userScriptsDir, userScript);
-                fs_1.default.unlinkSync(userScriptPath);
+                const userFilePath = path_1.default.join(userScriptsDir, userFile);
+                fs_1.default.unlinkSync(userFilePath);
                 cleanedCount++;
-                console.log(chalk_1.default.yellow(`  - ${userScript} (removed from registry)`));
+                console.log(chalk_1.default.yellow(`  - ${userFile} (removed from registry)`));
+                // Cleanup empty directories
+                try {
+                    const dir = path_1.default.dirname(userFilePath);
+                    if (fs_1.default.existsSync(dir) && fs_1.default.readdirSync(dir).length === 0) {
+                        fs_1.default.rmdirSync(dir);
+                    }
+                }
+                catch (e) { }
             }
             catch (error) {
-                console.warn(chalk_1.default.yellow(`⚠️ Could not remove obsolete script ${userScript}: ${error}`));
+                console.warn(chalk_1.default.yellow(`⚠️ Could not remove obsolete script ${userFile}: ${error}`));
             }
         }
     }
@@ -185,21 +198,6 @@ function getUserScriptPath(scriptName) {
 function userScriptExists(scriptName) {
     return fs_1.default.existsSync(getUserScriptPath(scriptName));
 }
-/**
- * Get all dependent script files from the registry (those with FRAIM source dependencies)
- */
-function getDependentRegistryScripts(registryPath) {
-    const scriptsPath = path_1.default.join(registryPath, 'scripts');
-    if (!fs_1.default.existsSync(scriptsPath)) {
-        return [];
-    }
-    const entries = fs_1.default.readdirSync(scriptsPath, { withFileTypes: true });
-    const allScripts = entries
-        .filter(entry => entry.isFile() && (entry.name.endsWith('.sh') || entry.name.endsWith('.ts') || entry.name.endsWith('.js')))
-        .map(entry => path_1.default.join(scriptsPath, entry.name));
-    // Only return scripts that have dependencies
-    return allScripts.filter(scriptPath => !isScriptSelfContained(scriptPath));
-}
 /**
  * Validate that all expected scripts are present in user directory
  */

package/dist/tests/test-end-to-end-hybrid-validation.js

@@ -187,52 +187,31 @@ async function testScriptCategorizationAccuracy() {
     try {
         const registryPath = path_1.default.resolve(__dirname, '../registry');
         if (!fs_1.default.existsSync(registryPath)) {
-            console.log('   ⚠️ Registry not found, skipping categorization accuracy test');
+            console.log('   ⚠️ Registry not found, skipping script sync test');
             return true;
         }
-        const { getRegistryScripts, getDependentRegistryScripts, isScriptSelfContained } = await Promise.resolve().then(() => __importStar(require('../src/utils/script-sync-utils')));
-        const selfContainedScripts = getRegistryScripts(registryPath);
-        const dependentScripts = getDependentRegistryScripts(registryPath);
-        console.log(`   📊 Categorization results:`);
-        console.log(`     Self-contained: ${selfContainedScripts.length} scripts`);
-        console.log(`     Dependent: ${dependentScripts.length} scripts`);
-        // Verify specific known categorizations
-        const knownSelfContained = [
+        const { getRegistryScripts } = await Promise.resolve().then(() => __importStar(require('../src/utils/script-sync-utils')));
+        const allScripts = getRegistryScripts(registryPath);
+        console.log(`   📊 Script sync results:`);
+        console.log(`     Total scripts: ${allScripts.length} scripts`);
+        // Verify some known scripts exist
+        const knownScripts = [
             'prep-issue.sh',
             'code-quality-check.sh',
             'exec-with-timeout.ts',
-            'evaluate-code-quality.ts'
-        ];
-        const knownDependent = [
-            'fraim-config.ts',
-            'build-scripts-generator.ts'
+            'evaluate-code-quality.ts',
+            'comprehensive-explorer.py',
+            'interactive-explorer.py',
+            'scrape-site.py'
         ];
-        const selfContainedNames = selfContainedScripts.map(p => path_1.default.basename(p));
-        const dependentNames = dependentScripts.map(p => path_1.default.basename(p));
-        for (const scriptName of knownSelfContained) {
-            const scriptPath = path_1.default.join(registryPath, 'scripts', scriptName);
-            if (fs_1.default.existsSync(scriptPath)) {
-                node_assert_1.default.ok(selfContainedNames.includes(scriptName), `${scriptName} should be categorized as self-contained`);
-                node_assert_1.default.ok(isScriptSelfContained(scriptPath), `${scriptName} should be detected as self-contained`);
-            }
-        }
-        for (const scriptName of knownDependent) {
+        const scriptNames = allScripts.map(p => path_1.default.basename(p));
+        for (const scriptName of knownScripts) {
             const scriptPath = path_1.default.join(registryPath, 'scripts', scriptName);
             if (fs_1.default.existsSync(scriptPath)) {
-                node_assert_1.default.ok(dependentNames.includes(scriptName), `${scriptName} should be categorized as dependent`);
-                node_assert_1.default.ok(!isScriptSelfContained(scriptPath), `${scriptName} should be detected as dependent`);
+                node_assert_1.default.ok(scriptNames.includes(scriptName), `${scriptName} should be included in sync`);
             }
         }
-        // Verify no script is in both categories
-        const intersection = selfContainedNames.filter(name => dependentNames.includes(name));
-        node_assert_1.default.strictEqual(intersection.length, 0, 'No script should be in both categories');
-        // Verify all scripts are categorized
-        const allScripts = fs_1.default.readdirSync(path_1.default.join(registryPath, 'scripts'))
-            .filter(file => file.endsWith('.sh') || file.endsWith('.ts') || file.endsWith('.js'));
-        const categorizedScripts = [...selfContainedNames, ...dependentNames];
-        const uncategorized = allScripts.filter(script => !categorizedScripts.includes(script));
-        node_assert_1.default.strictEqual(uncategorized.length, 0, `All scripts should be categorized. Uncategorized: ${uncategorized.join(', ')}`);
-        console.log('   ✅ Script categorization accuracy verified!');
+        console.log('   ✅ All known scripts are included');
         return true;
     }
     catch (error) {

package/dist/tests/test-hybrid-script-execution.js

@@ -77,24 +77,15 @@ const helper = require('../../src/utils/helper');
 console.log('This script also depends on FRAIM source code');
 `;
         fs_1.default.writeFileSync(path_1.default.join(scriptsDir, 'dependent.js'), dependentJS);
-        // Test the detection logic
-        const { isScriptSelfContained, getRegistryScripts, getDependentRegistryScripts } = await Promise.resolve().then(() => __importStar(require('../src/utils/script-sync-utils')));
-        // Test individual script detection
-        node_assert_1.default.ok(isScriptSelfContained(path_1.default.join(scriptsDir, 'self-contained.sh')), 'Shell script should be self-contained');
-        node_assert_1.default.ok(isScriptSelfContained(path_1.default.join(scriptsDir, 'self-contained.ts')), 'Self-contained TS should be detected');
-        node_assert_1.default.ok(!isScriptSelfContained(path_1.default.join(scriptsDir, 'dependent.ts')), 'Dependent TS should not be self-contained');
-        node_assert_1.default.ok(!isScriptSelfContained(path_1.default.join(scriptsDir, 'dependent.js')), 'Dependent JS should not be self-contained');
-        // Test batch detection
-        const selfContainedScripts = getRegistryScripts(tempDir);
-        const dependentScripts = getDependentRegistryScripts(tempDir);
-        node_assert_1.default.strictEqual(selfContainedScripts.length, 2, 'Should find 2 self-contained scripts');
-        node_assert_1.default.strictEqual(dependentScripts.length, 2, 'Should find 2 dependent scripts');
-        // Verify correct categorization
-        const selfContainedNames = selfContainedScripts.map(p => path_1.default.basename(p)).sort();
-        const dependentNames = dependentScripts.map(p => path_1.default.basename(p)).sort();
-        node_assert_1.default.deepStrictEqual(selfContainedNames, ['self-contained.sh', 'self-contained.ts'], 'Self-contained scripts correctly identified');
-        node_assert_1.default.deepStrictEqual(dependentNames, ['dependent.js', 'dependent.ts'], 'Dependent scripts correctly identified');
-        console.log('   ✅ Self-contained script detection verified!');
+        // Test the sync logic - all scripts should be synced now
+        const { getRegistryScripts } = await Promise.resolve().then(() => __importStar(require('../src/utils/script-sync-utils')));
+        // Test batch detection - should get all scripts
+        const allScripts = getRegistryScripts(tempDir);
+        node_assert_1.default.strictEqual(allScripts.length, 4, 'Should find all 4 scripts');
+        // Verify all scripts are included
+        const scriptNames = allScripts.map(p => path_1.default.basename(p)).sort();
+        node_assert_1.default.deepStrictEqual(scriptNames, ['dependent.js', 'dependent.ts', 'self-contained.sh', 'self-contained.ts'], 'All scripts should be included');
+        console.log('   ✅ Script sync detection verified!');
         return true;
     }
     catch (error) {
@@ -142,13 +133,13 @@ console.log('Dependent TypeScript script');
         // Override user directory for testing
         process.env.FRAIM_USER_DIR = userFraimDir;
         const syncResult = syncScriptsToUserDirectory(registryDir);
-        // Verify sync results
-        node_assert_1.default.strictEqual(syncResult.synced, 2, 'Should sync 2 self-contained scripts');
-        node_assert_1.default.strictEqual(syncResult.ephemeral, 1, 'Should identify 1 dependent script for ephemeral execution');
-        // Verify only self-contained scripts were copied
+        // Verify sync results - now all scripts are synced
+        node_assert_1.default.strictEqual(syncResult.synced, 3, 'Should sync all 3 scripts');
+        node_assert_1.default.strictEqual(syncResult.ephemeral, 0, 'No ephemeral scripts (all are synced)');
+        // Verify all scripts were copied
         node_assert_1.default.ok(fs_1.default.existsSync(path_1.default.join(userScriptsDir, 'shell-script.sh')), 'Shell script should be synced');
         node_assert_1.default.ok(fs_1.default.existsSync(path_1.default.join(userScriptsDir, 'self-contained.ts')), 'Self-contained TS should be synced');
-        node_assert_1.default.ok(!fs_1.default.existsSync(path_1.default.join(userScriptsDir, 'dependent.ts')), 'Dependent TS should NOT be synced');
+        node_assert_1.default.ok(fs_1.default.existsSync(path_1.default.join(userScriptsDir, 'dependent.ts')), 'Dependent TS should also be synced');
         // Verify executable permissions on Unix
         if (process.platform !== 'win32') {
             const shellScriptPath = path_1.default.join(userScriptsDir, 'shell-script.sh');
@@ -181,52 +172,32 @@ async function testActualRegistryScriptCategorization() {
             console.log('   ⚠️ Registry not found, skipping actual script categorization test');
             return true;
         }
-        const { getRegistryScripts, getDependentRegistryScripts } = await Promise.resolve().then(() => __importStar(require('../src/utils/script-sync-utils')));
-        const selfContainedScripts = getRegistryScripts(registryPath);
-        const dependentScripts = getDependentRegistryScripts(registryPath);
-        console.log(`   📊 Found ${selfContainedScripts.length} self-contained scripts:`);
-        for (const script of selfContainedScripts) {
+        const { getRegistryScripts } = await Promise.resolve().then(() => __importStar(require('../src/utils/script-sync-utils')));
+        const allScripts = getRegistryScripts(registryPath);
+        console.log(`   📊 Found ${allScripts.length} scripts to sync:`);
+        for (const script of allScripts) {
             console.log(`     ✅ ${path_1.default.basename(script)}`);
         }
-        console.log(`   📊 Found ${dependentScripts.length} dependent scripts:`);
-        for (const script of dependentScripts) {
-            console.log(`     🔗 ${path_1.default.basename(script)}`);
-        }
-        // Verify expected scripts are categorized correctly
-        const selfContainedNames = selfContainedScripts.map(p => path_1.default.basename(p));
-        const dependentNames = dependentScripts.map(p => path_1.default.basename(p));
-        // prep-issue.sh should be self-contained (it's a shell script)
-        node_assert_1.default.ok(selfContainedNames.includes('prep-issue.sh'), 'prep-issue.sh should be self-contained');
-        // Scripts with FRAIM imports should be dependent
-        const expectedDependentScripts = [
-            'fraim-config.ts',
-            'build-scripts-generator.ts'
-        ];
-        for (const expectedDependent of expectedDependentScripts) {
-            if (fs_1.default.existsSync(path_1.default.join(registryPath, 'scripts', expectedDependent))) {
-                node_assert_1.default.ok(dependentNames.includes(expectedDependent), `${expectedDependent} should be dependent`);
-            }
-        }
-        // Scripts that should be self-contained
-        const expectedSelfContainedScripts = [
-            'prep-issue.sh',
-            'evaluate-code-quality.ts', // This only uses __dirname and standard modules
-            'code-quality-check.sh'
+        // Verify expected scripts are included
+        const scriptNames = allScripts.map(p => path_1.default.basename(p));
+        // prep-issue.sh should be included
+        node_assert_1.default.ok(scriptNames.includes('prep-issue.sh'), 'prep-issue.sh should be included');
+        // Python scripts should be included
+        const expectedPythonScripts = [
+            'comprehensive-explorer.py',
+            'interactive-explorer.py',
+            'scrape-site.py'
         ];
-        for (const expectedSelfContained of expectedSelfContainedScripts) {
-            if (fs_1.default.existsSync(path_1.default.join(registryPath, 'scripts', expectedSelfContained))) {
-                node_assert_1.default.ok(selfContainedNames.includes(expectedSelfContained), `${expectedSelfContained} should be self-contained`);
+        for (const expectedScript of expectedPythonScripts) {
+            if (fs_1.default.existsSync(path_1.default.join(registryPath, 'scripts', expectedScript))) {
+                node_assert_1.default.ok(scriptNames.includes(expectedScript), `${expectedScript} should be included`);
             }
         }
-        // Verify we have a reasonable split
-        const totalScripts = selfContainedScripts.length + dependentScripts.length;
-        node_assert_1.default.ok(totalScripts > 0, 'Should find some scripts in registry');
-        node_assert_1.default.ok(selfContainedScripts.length > 0, 'Should have some self-contained scripts');
-        console.log('   ✅ Actual registry script categorization verified!');
+        console.log('   ✅ Actual registry script sync verified!');
         return true;
     }
     catch (error) {
-        console.error('   ❌ Registry script categorization test failed:', error);
+        console.error('   ❌ Registry script sync test failed:', error);
         return false;
     }
 }