@wundam/orchex 1.0.0-rc.21 → 1.0.0-rc.22

package/dist/orchestrator.js

@@ -540,8 +540,9 @@ async function executeWaveInternal(projectDir, executor, options, logger) {
             };
         }
         catch (error) {
-            const catchError = error.message;
-            const catchAnalysis = analyzeError(catchError, 'transport');
+            const err = error;
+            const catchError = err.name && err.name !== 'Error' ? `${err.name}: ${err.message}` : err.message;
+            const catchAnalysis = analyzeError(err.stack ?? catchError, 'transport');
             await logger.error('stream_failed', {
                 id: stream.id,
                 phase: 'execution',
@@ -568,21 +569,28 @@ async function executeWaveInternal(projectDir, executor, options, logger) {
         }
     });
     // Wrap each promise with stream ID so rejections are identifiable
-    const taggedPromises = executePromises.map((p, i) => p.catch(err => ({
-        id: activeStreams[i]?.id ?? `wave-${targetWave.number}-idx-${i}`,
-        name: activeStreams[i]?.name ?? 'unknown',
-        status: 'failed',
-        error: err.message ?? String(err),
-        errorDetail: { category: 'unknown', retryable: true, selfHealable: false, suggestion: 'Check orchestrator logs' },
-        tokensUsed: { input: 0, output: 0 },
-    })));
+    const taggedPromises = executePromises.map((p, i) => p.catch(err => {
+        const errorMsg = err.message ?? String(err);
+        const errorStack = err.stack;
+        const fullError = errorStack ? `${errorMsg}\n${errorStack}` : errorMsg;
+        const analysis = analyzeError(fullError, 'transport');
+        return {
+            id: activeStreams[i]?.id ?? `wave-${targetWave.number}-idx-${i}`,
+            name: activeStreams[i]?.name ?? 'unknown',
+            status: 'failed',
+            error: errorMsg,
+            errorDetail: { category: analysis.category, retryable: analysis.retryable, selfHealable: analysis.selfHealable, suggestion: analysis.suggestion },
+            tokensUsed: { input: 0, output: 0 },
+        };
+    }));
     // Promise.allSettled — one failure doesn't kill the wave
     const settled = await Promise.allSettled(taggedPromises);
     // Calculate parallel execution time (wall clock)
     const waveEndTime = Date.now();
     const waveCompletedAt = new Date().toISOString();
     const parallelMs = waveEndTime - waveStartTime;
-    for (const result of settled) {
+    for (let idx = 0; idx < settled.length; idx++) {
+        const result = settled[idx];
         if (result.status === 'fulfilled') {
             streamResults.push(result.value);
         }
@@ -590,8 +598,8 @@ async function executeWaveInternal(projectDir, executor, options, logger) {
             const rejectedError = result.reason?.message ?? 'Unknown error';
             const rejectedAnalysis = analyzeError(rejectedError, 'transport');
             streamResults.push({
-                id: 'unknown',
-                name: 'unknown',
+                id: activeStreams[idx]?.id ?? `wave-${targetWave.number}-idx-${idx}`,
+                name: activeStreams[idx]?.name ?? 'unknown',
                 status: 'failed',
                 error: rejectedError,
                 errorDetail: { category: rejectedAnalysis.category, retryable: rejectedAnalysis.retryable, selfHealable: rejectedAnalysis.selfHealable, suggestion: rejectedAnalysis.suggestion },
@@ -669,7 +677,7 @@ async function executeWaveInternal(projectDir, executor, options, logger) {
                 .filter(s => s && s.trim())
                 .join('\n')
                 || 'unknown error';
-            const errorSummary = `Verify failed: ${failed.command}: ${verifyError.slice(0, 500)}`;
+            let errorSummary = `Verify failed: ${failed.command}: ${verifyError.slice(0, 500)}`;
             const verifyAnalysis = analyzeError(verifyError, 'verify');
             verifyDetails.push(`${sr.id}: ${errorSummary}`);
             await updateStreamStatus(projectDir, sr.id, 'failed', errorSummary);
@@ -681,6 +689,7 @@ async function executeWaveInternal(projectDir, executor, options, logger) {
                 isolated: otherBackups.length > 0,
             });
             // Rollback file changes for failed verify — prevents leaving orphan files on disk
+            let rollbackFailed = false;
             const streamBackup = successBackups.find(b => b.streamId === sr.id);
             if (streamBackup) {
                 try {
@@ -688,12 +697,18 @@ async function executeWaveInternal(projectDir, executor, options, logger) {
                     await logger.info('verify_rollback', { stream: sr.id, files: streamBackup.entries.length + streamBackup.createdFiles.length });
                 }
                 catch (rollbackErr) {
-                    await logger.warn('verify_rollback_failed', { stream: sr.id, error: rollbackErr.message });
+                    rollbackFailed = true;
+                    const rollbackMsg = rollbackErr.message;
+                    await logger.warn('verify_rollback_failed', { stream: sr.id, error: rollbackMsg });
+                    errorSummary += ` [ROLLBACK FAILED: ${rollbackMsg} — files may remain on disk]`;
                 }
             }
             sr.status = 'failed';
             sr.error = errorSummary;
-            sr.errorDetail = { category: verifyAnalysis.category, retryable: verifyAnalysis.retryable, selfHealable: verifyAnalysis.selfHealable, suggestion: verifyAnalysis.suggestion };
+            const suggestion = rollbackFailed
+                ? `${verifyAnalysis.suggestion}. WARNING: Rollback failed — manually check files owned by this stream.`
+                : verifyAnalysis.suggestion;
+            sr.errorDetail = { category: verifyAnalysis.category, retryable: verifyAnalysis.retryable, selfHealable: verifyAnalysis.selfHealable && !rollbackFailed, suggestion };
         }
         else {
             verifyPassed++;

package/dist/ownership.js

@@ -107,8 +107,12 @@ export function checkOwnership(operations, owns, options = {}) {
     }
     return { violations, warnings, allowed };
 }
+function normalizePath(p) {
+    // Strip leading "./" — LLM artifacts may include it inconsistently
+    return p.startsWith('./') ? p.slice(2) : p;
+}
 function checkSingleOperation(op, owns, options) {
-    const filePath = op.path;
+    const filePath = normalizePath(op.path);
     // SECURITY: Block path traversal (non-negotiable, checked first)
     if (filePath.includes('..')) {
         return {
@@ -141,26 +145,28 @@ function checkSingleOperation(op, owns, options) {
             warning: `Common file '${filePath}' created (not in owns list)`,
         };
     }
-    // Not allowed
+    // Not allowed — include owns list for debuggability
     return {
-        violation: `${op.type} on '${filePath}' is outside owned files`,
+        violation: `${op.type} on '${filePath}' is outside owned files [${owns.join(', ')}]`,
     };
 }
 /**
  * Check if a path is explicitly covered by an ownership pattern.
  */
 function isExplicitlyOwned(filePath, owns) {
+    const normalizedFile = normalizePath(filePath);
     return owns.some((pattern) => {
+        const normalizedPattern = normalizePath(pattern);
         // Directory pattern: "src/" matches "src/foo.ts"
-        if (pattern.endsWith('/')) {
-            return filePath.startsWith(pattern);
+        if (normalizedPattern.endsWith('/')) {
+            return normalizedFile.startsWith(normalizedPattern);
         }
         // Glob pattern: "src/*.ts" matches "src/foo.ts"
-        if (pattern.includes('*')) {
-            return matchGlobPattern(pattern, filePath);
+        if (normalizedPattern.includes('*')) {
+            return matchGlobPattern(normalizedPattern, normalizedFile);
         }
         // Exact match
-        return filePath === pattern;
+        return normalizedFile === normalizedPattern;
     });
 }
 /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@wundam/orchex",
   "mcpName": "io.github.wundam/orchex",
-  "version": "1.0.0-rc.21",
+  "version": "1.0.0-rc.22",
   "description": "Autopilot AI orchestration — auto-plan, parallelize, and execute with ownership enforcement",
   "type": "module",
   "main": "dist/index.js",
@@ -20,11 +20,11 @@
   "author": "Wundam LLC",
   "repository": {
     "type": "git",
-    "url": "https://orchex.dev"
+    "url": "https://github.com/wundam/orchex-community"
   },
   "homepage": "https://orchex.dev",
   "bugs": {
-    "url": "https://orchex.dev/support"
+    "url": "https://github.com/wundam/orchex-community/discussions"
   },
   "keywords": [
     "mcp",