agentic-qe 3.15.16 → 3.15.18

package/dist/domains/learning-optimization/pattern-archive.d.ts

@@ -1,5 +1,5 @@
 /**
- * Agentic QE v3 - Archiving one learned pattern (#1071, #1106)
+ * Agentic QE v3 - Archiving one learned pattern (#1071, #1106, #1149)
  *
  * Archiving is a move inside the `learning-optimization` namespace:
  *
@@ -12,20 +12,67 @@
  * - Only the active key of the given pattern is deleted.
  * - The active record must still be that pattern (same id, and the same scores
  *   and last use) when the archive runs, or nothing is written or deleted.
- * - The archive copy is read back before the active key is deleted, so a
- *   failed or partial write never loses the pattern.
+ * - The archive copy is the stored active record. It is read back and compared
+ *   in full before the active key is deleted, so a failed or partial write
+ *   never loses the pattern (#1149).
+ * - Compare-and-delete: the active key is deleted only while the active record
+ *   still equals the archive copy. An update made after the copy keeps the
+ *   pattern active (#1149).
+ * - A copy that is not followed by a delete is removed again, so no archive
+ *   row is left for a pattern that is still active (#1149).
+ * - Moves on one backend run one at a time (`withPatternMoveLock`), so two
+ *   merges of the same patterns cannot both succeed (#1149). The lock is
+ *   per process; the backend has no transactions to lock across processes.
  */
 import type { MemoryBackend } from '../../kernel/interfaces.js';
 import type { LearnedPattern } from './interfaces.js';
-export type ArchiveOutcome = 'archived' | 'missing' | 'failed';
+/**
+ * Outcome of one move:
+ * - `archived`: copied, verified, and removed from the active set
+ * - `missing`: the active record is gone; nothing was written
+ * - `changed`: the active record changed since it was selected, or during
+ *   the move; it stays active and no archive copy is kept
+ * - `failed`: the archive copy could not be verified; the pattern stays active
+ */
+export type ArchiveOutcome = 'archived' | 'missing' | 'changed' | 'failed';
+/**
+ * Outcome of removing the active key after a copy:
+ * - `removed`: the active record equalled the archive copy and was deleted
+ * - `missing`: the active record was already gone
+ * - `changed`: the active record changed after the copy; left active
+ * - `failed`: the archive copy is gone or no longer verifies; left active
+ */
+export type RemoveOutcome = 'removed' | 'missing' | 'changed' | 'failed';
+/**
+ * JSON with object keys sorted, so two records compare equal exactly when
+ * they store the same values. Dates serialize as ISO strings, as they do in
+ * the backend.
+ */
+export declare function canonicalJson(value: unknown): string;
 /**
  * Write the archive copy of one pattern and read it back, without touching
- * the active key. `copied` means the copy is verified and the active record
- * is still the given pattern.
+ * the active key. `copied` means the copy is verified in full and the active
+ * record is still the given pattern. On `failed` the unverified copy has been
+ * removed again.
  */
 export declare function copyPatternToArchive(memory: MemoryBackend, pattern: LearnedPattern, archivedAt?: Date): Promise<'copied' | Exclude<ArchiveOutcome, 'archived'>>;
-/** Remove the active key of a pattern whose archive copy was verified. */
-export declare function removeArchivedPattern(memory: MemoryBackend, pattern: LearnedPattern): Promise<void>;
+/**
+ * Compare-and-delete the active key of a pattern whose archive copy was
+ * verified: delete only while the active record still equals the copy.
+ */
+export declare function removeArchivedPattern(memory: MemoryBackend, pattern: LearnedPattern): Promise<RemoveOutcome>;
+/**
+ * Remove the archive copy of a pattern that is still active, after a move
+ * that did not complete. The copy is kept when the active record is gone, so
+ * a pattern is never left without either record.
+ */
+export declare function discardArchiveCopy(memory: MemoryBackend, pattern: LearnedPattern): Promise<boolean>;
 /** Move one pattern to its archive key in the learning namespace. */
 export declare function archiveSelectedPattern(memory: MemoryBackend, pattern: LearnedPattern, archivedAt?: Date): Promise<ArchiveOutcome>;
+/**
+ * Run `fn` after every earlier pattern move on the same backend has settled.
+ * Not re-entrant: `fn` must not call `withPatternMoveLock` (or
+ * `archiveSelectedPattern`) on the same backend.
+ */
+export declare function withPatternMoveLock<T>(memory: MemoryBackend, fn: () => Promise<T>): Promise<T>;
 //# sourceMappingURL=pattern-archive.d.ts.map

package/dist/domains/learning-optimization/pattern-archive.js

@@ -1,5 +1,5 @@
 /**
- * Agentic QE v3 - Archiving one learned pattern (#1071, #1106)
+ * Agentic QE v3 - Archiving one learned pattern (#1071, #1106, #1149)
  *
  * Archiving is a move inside the `learning-optimization` namespace:
  *
@@ -12,38 +12,111 @@
  * - Only the active key of the given pattern is deleted.
  * - The active record must still be that pattern (same id, and the same scores
  *   and last use) when the archive runs, or nothing is written or deleted.
- * - The archive copy is read back before the active key is deleted, so a
- *   failed or partial write never loses the pattern.
+ * - The archive copy is the stored active record. It is read back and compared
+ *   in full before the active key is deleted, so a failed or partial write
+ *   never loses the pattern (#1149).
+ * - Compare-and-delete: the active key is deleted only while the active record
+ *   still equals the archive copy. An update made after the copy keeps the
+ *   pattern active (#1149).
+ * - A copy that is not followed by a delete is removed again, so no archive
+ *   row is left for a pattern that is still active (#1149).
+ * - Moves on one backend run one at a time (`withPatternMoveLock`), so two
+ *   merges of the same patterns cannot both succeed (#1149). The lock is
+ *   per process; the backend has no transactions to lock across processes.
  */
 import { LEARNING_NS, LEARNING_PATTERN_KEY_PREFIX, isActivePatternKey } from './active-patterns.js';
+const activeKeyOf = (id) => `${LEARNING_PATTERN_KEY_PREFIX}${id}`;
+const archiveKeyOf = (id) => `${LEARNING_PATTERN_KEY_PREFIX}archived:${id}`;
+/**
+ * JSON with object keys sorted, so two records compare equal exactly when
+ * they store the same values. Dates serialize as ISO strings, as they do in
+ * the backend.
+ */
+export function canonicalJson(value) {
+    return JSON.stringify(value, (_key, v) => v && typeof v === 'object' && !Array.isArray(v)
+        ? Object.fromEntries(Object.entries(v).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)))
+        : v);
+}
+/** The archive copy without its `archivedAt` stamp, i.e. the record that was archived. */
+function archivedRecord(copy) {
+    const { archivedAt: _archivedAt, ...record } = copy;
+    return record;
+}
 /**
  * Write the archive copy of one pattern and read it back, without touching
- * the active key. `copied` means the copy is verified and the active record
- * is still the given pattern.
+ * the active key. `copied` means the copy is verified in full and the active
+ * record is still the given pattern. On `failed` the unverified copy has been
+ * removed again.
  */
 export async function copyPatternToArchive(memory, pattern, archivedAt = new Date()) {
-    const activeKey = `${LEARNING_PATTERN_KEY_PREFIX}${pattern.id}`;
+    const activeKey = activeKeyOf(pattern.id);
     if (!isActivePatternKey(activeKey))
         return 'missing';
     const current = await memory.get(activeKey, LEARNING_NS);
-    if (!current || current.id !== pattern.id || changedSinceSelection(current, pattern))
+    if (!current || current.id !== pattern.id)
         return 'missing';
-    const archiveKey = `${LEARNING_PATTERN_KEY_PREFIX}archived:${pattern.id}`;
-    await memory.set(archiveKey, { ...pattern, archivedAt }, { ...LEARNING_NS, persist: true });
+    if (changedSinceSelection(current, pattern))
+        return 'changed';
+    const archiveKey = archiveKeyOf(pattern.id);
+    const expected = { ...current, archivedAt };
+    await memory.set(archiveKey, expected, { ...LEARNING_NS, persist: true });
     const copy = await memory.get(archiveKey, LEARNING_NS);
-    return copy && copy.id === pattern.id ? 'copied' : 'failed';
+    if (copy && canonicalJson(copy) === canonicalJson(expected))
+        return 'copied';
+    await discardArchiveCopy(memory, pattern);
+    return 'failed';
 }
-/** Remove the active key of a pattern whose archive copy was verified. */
+/**
+ * Compare-and-delete the active key of a pattern whose archive copy was
+ * verified: delete only while the active record still equals the copy.
+ */
 export async function removeArchivedPattern(memory, pattern) {
-    await memory.delete(`${LEARNING_PATTERN_KEY_PREFIX}${pattern.id}`, LEARNING_NS);
+    const activeKey = activeKeyOf(pattern.id);
+    const active = await memory.get(activeKey, LEARNING_NS);
+    if (!active)
+        return 'missing';
+    const copy = await memory.get(archiveKeyOf(pattern.id), LEARNING_NS);
+    if (!copy || typeof copy !== 'object' || copy.id !== pattern.id)
+        return 'failed';
+    if (canonicalJson(active) !== canonicalJson(archivedRecord(copy)))
+        return 'changed';
+    await memory.delete(activeKey, LEARNING_NS);
+    return 'removed';
+}
+/**
+ * Remove the archive copy of a pattern that is still active, after a move
+ * that did not complete. The copy is kept when the active record is gone, so
+ * a pattern is never left without either record.
+ */
+export async function discardArchiveCopy(memory, pattern) {
+    if (!(await memory.get(activeKeyOf(pattern.id), LEARNING_NS)))
+        return false;
+    return memory.delete(archiveKeyOf(pattern.id), LEARNING_NS);
 }
 /** Move one pattern to its archive key in the learning namespace. */
 export async function archiveSelectedPattern(memory, pattern, archivedAt = new Date()) {
-    const copied = await copyPatternToArchive(memory, pattern, archivedAt);
-    if (copied !== 'copied')
-        return copied;
-    await removeArchivedPattern(memory, pattern);
-    return 'archived';
+    return withPatternMoveLock(memory, async () => {
+        const copied = await copyPatternToArchive(memory, pattern, archivedAt);
+        if (copied !== 'copied')
+            return copied;
+        const removed = await removeArchivedPattern(memory, pattern);
+        if (removed === 'removed')
+            return 'archived';
+        await discardArchiveCopy(memory, pattern);
+        return removed;
+    });
+}
+const moveQueues = new WeakMap();
+/**
+ * Run `fn` after every earlier pattern move on the same backend has settled.
+ * Not re-entrant: `fn` must not call `withPatternMoveLock` (or
+ * `archiveSelectedPattern`) on the same backend.
+ */
+export function withPatternMoveLock(memory, fn) {
+    const previous = moveQueues.get(memory) ?? Promise.resolve();
+    const run = previous.then(fn, fn);
+    moveQueues.set(memory, run.then(() => undefined, () => undefined));
+    return run;
 }
 /** True when the stored record's scores or last use differ from the selected snapshot. */
 function changedSinceSelection(current, selected) {

package/dist/domains/learning-optimization/pattern-consolidation.js

@@ -6,12 +6,27 @@
  * to predict the merged pattern, so a dry run selects the same trims as a
  * real run.
  */
-import { isMeasuredPattern } from './reward-source.js';
+import { patternEvidenceOf } from './reward-source.js';
 /** Usage-weighted mean of one score (equal weights when nothing was used). */
 function usageWeighted(patterns, score) {
     const totalUsage = patterns.reduce((sum, p) => sum + p.usageCount, 0);
     return patterns.reduce((sum, p) => sum + score(p) * (totalUsage > 0 ? p.usageCount / totalUsage : 1 / patterns.length), 0);
 }
+/**
+ * #1147: a merge keeps the most conservative evidence of its sources:
+ * `assigned` if any source is, else `pre-1120` if any source is, else
+ * `measured`. `pre-1120` has no tag of its own; the merge is left untagged,
+ * which `patternEvidenceOf` reads as `pre-1120` (the kept template is a
+ * source's, so it is not read as assigned unless a source was).
+ */
+function mergedEvidence(patterns) {
+    const evidence = new Set(patterns.map(patternEvidenceOf));
+    if (evidence.has('assigned'))
+        return 'assigned';
+    if (evidence.has('pre-1120'))
+        return 'pre-1120';
+    return 'measured';
+}
 /** Merge similar patterns: best template, combined contexts, weighted scores. */
 export function buildConsolidatedPattern(patterns, id, now = new Date()) {
     const bestPattern = patterns.reduce((best, current) => current.successRate > best.successRate ? current : best);
@@ -22,6 +37,7 @@ export function buildConsolidatedPattern(patterns, id, now = new Date()) {
         codeContext: bestPattern.context.codeContext,
         tags: [...new Set(patterns.flatMap((p) => p.context.tags))],
     };
+    const evidence = mergedEvidence(patterns);
     return {
         id,
         type: bestPattern.type,
@@ -35,7 +51,7 @@ export function buildConsolidatedPattern(patterns, id, now = new Date()) {
         template: bestPattern.template,
         createdAt: now,
         lastUsedAt: now,
-        rewardSource: patterns.every(isMeasuredPattern) ? 'measured' : 'assigned',
+        ...(evidence === 'pre-1120' ? {} : { rewardSource: evidence }),
     };
 }
 //# sourceMappingURL=pattern-consolidation.js.map

package/dist/domains/learning-optimization/pattern-merge.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Agentic QE v3 - Committing one pattern merge (#1106, #1149)
+ *
+ * `LearningCoordinatorService.consolidatePatterns` builds the consolidated
+ * pattern; this module moves the sources out of the active set:
+ *
+ * 1. Every source pattern's archive copy is written and verified.
+ * 2. The consolidated pattern is stored and read back in full.
+ * 3. The sources are removed one by one with compare-and-delete.
+ *
+ * A failure in steps 1-2, or before the first source is removed, rolls the
+ * merge back: the consolidated pattern and the archive copies are deleted and
+ * every source stays active. A failure after a source was removed keeps the
+ * consolidated pattern (it now holds that source's data) and reports each
+ * source's real state. Callers run this under `withPatternMoveLock`.
+ */
+import type { MemoryBackend } from '../../kernel/interfaces.js';
+import { type Result } from '../../shared/types/index.js';
+import type { LearnedPattern } from './interfaces.js';
+/**
+ * Archive `sources`, store `consolidated` with `store`, then remove the
+ * sources. Returns the consolidated pattern only when every source left the
+ * active set.
+ */
+export declare function commitPatternMerge(memory: MemoryBackend, sources: readonly LearnedPattern[], consolidated: LearnedPattern, store: (pattern: LearnedPattern) => Promise<void>, archivedAt?: Date): Promise<Result<LearnedPattern>>;
+//# sourceMappingURL=pattern-merge.d.ts.map

package/dist/domains/learning-optimization/pattern-merge.js

@@ -0,0 +1,127 @@
+/**
+ * Agentic QE v3 - Committing one pattern merge (#1106, #1149)
+ *
+ * `LearningCoordinatorService.consolidatePatterns` builds the consolidated
+ * pattern; this module moves the sources out of the active set:
+ *
+ * 1. Every source pattern's archive copy is written and verified.
+ * 2. The consolidated pattern is stored and read back in full.
+ * 3. The sources are removed one by one with compare-and-delete.
+ *
+ * A failure in steps 1-2, or before the first source is removed, rolls the
+ * merge back: the consolidated pattern and the archive copies are deleted and
+ * every source stays active. A failure after a source was removed keeps the
+ * consolidated pattern (it now holds that source's data) and reports each
+ * source's real state. Callers run this under `withPatternMoveLock`.
+ */
+import { err, ok } from '../../shared/types/index.js';
+import { toError } from '../../shared/error-utils.js';
+import { LEARNING_NS, LEARNING_PATTERN_KEY_PREFIX } from './active-patterns.js';
+import { canonicalJson, copyPatternToArchive, discardArchiveCopy, removeArchivedPattern, } from './pattern-archive.js';
+const LEFT_ACTIVE = 'nothing was merged and every source pattern was left active';
+const REMOVE_REASONS = {
+    changed: 'changed after its archive copy',
+    failed: 'archive copy no longer verifies',
+};
+/**
+ * Archive `sources`, store `consolidated` with `store`, then remove the
+ * sources. Returns the consolidated pattern only when every source left the
+ * active set.
+ */
+export async function commitPatternMerge(memory, sources, consolidated, store, archivedAt = new Date()) {
+    const copied = [];
+    let storeAttempted = false;
+    const rollBack = async (reason) => {
+        const problems = await undoMerge(memory, copied, storeAttempted ? consolidated : undefined);
+        return err(new Error(`${reason}; ${LEFT_ACTIVE}${problems.length ? ` (rollback incomplete: ${problems.join('; ')})` : ''}`));
+    };
+    try {
+        let notCopied = 0;
+        for (const source of sources) {
+            if ((await copyPatternToArchive(memory, source, archivedAt)) === 'copied')
+                copied.push(source);
+            else
+                notCopied++;
+        }
+        if (notCopied > 0) {
+            return rollBack(`${notCopied} of ${sources.length} source patterns could not be archived (archive copy not verified)`);
+        }
+        storeAttempted = true;
+        await store(consolidated);
+        const stored = await memory.get(`${LEARNING_PATTERN_KEY_PREFIX}${consolidated.id}`, LEARNING_NS);
+        if (!stored || canonicalJson(stored) !== canonicalJson(consolidated)) {
+            return rollBack('Consolidated pattern could not be read back');
+        }
+    }
+    catch (error) {
+        return rollBack(`Merge failed before any source pattern was removed: ${toError(error).message}`);
+    }
+    const removed = [];
+    for (let i = 0; i < sources.length; i++) {
+        let reason;
+        try {
+            const outcome = await removeArchivedPattern(memory, sources[i]);
+            if (outcome === 'removed' || outcome === 'missing') {
+                removed.push(outcome === 'missing' ? `${sources[i].id} (already gone)` : sources[i].id);
+                continue;
+            }
+            reason = REMOVE_REASONS[outcome];
+        }
+        catch (error) {
+            // A delete can fail after it took effect: report what is stored.
+            if (await isGone(memory, sources[i])) {
+                removed.push(sources[i].id);
+                continue;
+            }
+            reason = `delete failed: ${toError(error).message}`;
+        }
+        if (removed.length === 0)
+            return rollBack(`Source pattern ${sources[i].id} was not removed (${reason})`);
+        const leftActive = sources.slice(i);
+        const problems = [];
+        for (const source of leftActive) {
+            try {
+                await discardArchiveCopy(memory, source);
+            }
+            catch (error) {
+                problems.push(`archive copy of ${source.id} not removed: ${toError(error).message}`);
+            }
+        }
+        const states = leftActive.map((s, j) => `${s.id} (${j === 0 ? reason : 'not attempted'})`);
+        return err(new Error(`Merge partially applied: consolidated pattern ${consolidated.id} is active; ` +
+            `removed: ${removed.join(', ')}; left active: ${states.join(', ')}` +
+            (problems.length ? `; ${problems.join('; ')}` : '')));
+    }
+    return ok(consolidated);
+}
+/** True only when the source's active key is confirmed absent. */
+async function isGone(memory, source) {
+    try {
+        return !(await memory.get(`${LEARNING_PATTERN_KEY_PREFIX}${source.id}`, LEARNING_NS));
+    }
+    catch {
+        return false;
+    }
+}
+/** Delete the consolidated pattern and the archive copies of sources that are still active. */
+async function undoMerge(memory, copied, consolidated) {
+    const problems = [];
+    if (consolidated) {
+        try {
+            await memory.delete(`${LEARNING_PATTERN_KEY_PREFIX}${consolidated.id}`, LEARNING_NS);
+        }
+        catch (error) {
+            problems.push(`consolidated pattern ${consolidated.id} not removed: ${toError(error).message}`);
+        }
+    }
+    for (const source of copied) {
+        try {
+            await discardArchiveCopy(memory, source);
+        }
+        catch (error) {
+            problems.push(`archive copy of ${source.id} not removed: ${toError(error).message}`);
+        }
+    }
+    return problems;
+}
+//# sourceMappingURL=pattern-merge.js.map

package/dist/domains/learning-optimization/services/learning-coordinator.js

@@ -9,7 +9,8 @@ import { rehydrateDates } from '../../../shared/utils/kv-date-rehydrate.js';
 import { toError } from '../../../shared/error-utils.js';
 import { readActivePatterns } from '../active-patterns.js';
 import { isMeasuredPattern, partitionByRewardSource, patternEvidenceOf } from '../reward-source.js';
-import { copyPatternToArchive, removeArchivedPattern } from '../pattern-archive.js';
+import { withPatternMoveLock } from '../pattern-archive.js';
+import { commitPatternMerge } from '../pattern-merge.js';
 import { buildConsolidatedPattern } from '../pattern-consolidation.js';
 import { createQEFlashAttention, } from '../../../integrations/ruvector/wrappers.js';
 import { getClaudeModelForTier } from '../../../shared/llm/model-registry.js';
@@ -346,41 +347,26 @@ Provide:
             if (patternIds.length < 2) {
                 return err(new Error('Need at least 2 patterns to consolidate'));
             }
-            const patterns = [];
-            for (const id of patternIds) {
-                const pattern = await this.memory.get(`learning:pattern:${id}`, LEARNING_NS);
-                if (pattern) {
-                    patterns.push(pattern);
+            // #1149: one move at a time per backend. A second merge of the same ids
+            // reads its sources after the first has removed them, and stops.
+            return await withPatternMoveLock(this.memory, async () => {
+                const patterns = [];
+                for (const id of patternIds) {
+                    const pattern = await this.memory.get(`learning:pattern:${id}`, LEARNING_NS);
+                    if (pattern) {
+                        patterns.push(pattern);
+                    }
                 }
-            }
-            if (patterns.length < 2) {
-                return err(new Error('Not enough valid patterns found'));
-            }
-            // Merge patterns - take best template, combine contexts
-            const consolidatedPattern = buildConsolidatedPattern(patterns, uuidv4());
-            // #1106: all or nothing. Every source pattern's archive copy is written
-            // and read back first; then the consolidated pattern is stored and read
-            // back; only then are the source patterns removed from the active set.
-            // If any step fails, no source pattern is deleted.
-            const archivedAt = new Date();
-            let notCopied = 0;
-            for (const pattern of patterns) {
-                if (await copyPatternToArchive(this.memory, pattern, archivedAt) !== 'copied')
-                    notCopied++;
-            }
-            if (notCopied > 0) {
-                return err(new Error(`${notCopied} of ${patterns.length} source patterns could not be archived (archive copy not verified); ` +
-                    'nothing was merged and every source pattern was left active'));
-            }
-            await this.storePattern(consolidatedPattern);
-            const stored = await this.memory.get(`learning:pattern:${consolidatedPattern.id}`, LEARNING_NS);
-            if (!stored || stored.id !== consolidatedPattern.id) {
-                return err(new Error('Consolidated pattern could not be read back; nothing was merged and every source pattern was left active'));
-            }
-            for (const pattern of patterns) {
-                await removeArchivedPattern(this.memory, pattern);
-            }
-            return ok(consolidatedPattern);
+                if (patterns.length < 2) {
+                    return err(new Error('Not enough valid patterns found'));
+                }
+                // Merge patterns - take best template, combine contexts
+                const consolidatedPattern = buildConsolidatedPattern(patterns, uuidv4());
+                // #1106/#1149: every source is archived and verified, then the
+                // consolidated pattern is stored and verified, then the sources are
+                // removed with compare-and-delete; failures roll back (pattern-merge.ts).
+                return commitPatternMerge(this.memory, patterns, consolidatedPattern, (p) => this.storePattern(p));
+            });
         }
         catch (error) {
             return err(toError(error));

package/dist/domains/test-execution/coordinator.d.ts

@@ -131,7 +131,9 @@ export declare class TestExecutionCoordinator extends BaseDomainCoordinator<Test
      */
     private retryFailures;
     /**
-     * Detect test framework from file patterns and project configuration
+     * Fallback framework from file names. With no explicit framework, each
+     * runner project's own config still decides between jest and vitest (#1272),
+     * and Python files always run with pytest (#1248).
      */
     private detectFramework;
     /**

package/dist/domains/test-execution/coordinator.js

@@ -16,6 +16,7 @@ import { createDomainFinding, } from '../../coordination/consensus/domain-findin
 // CQ-002: Base domain coordinator
 import { BaseDomainCoordinator, } from '../base-domain-coordinator.js';
 import { toError } from '../../shared/error-utils.js';
+import { isPythonTestFile } from '../../shared/pytest-junit-report.js';
 import { createMinCutTestOptimizer, } from './services/mincut-test-optimizer.js';
 // ============================================================================
 // Coordinator Configuration
@@ -146,6 +147,8 @@ export class TestExecutionCoordinator extends BaseDomainCoordinator {
             });
         }
         const framework = request.framework ?? this.detectFramework(testsToRun);
+        // #1272: without an explicit framework, each runner project's config decides.
+        const frameworkFromConfig = request.framework === undefined;
         const workers = request.workers ?? Math.min(4, Math.max(1, testsToRun.length));
         // Batched runners own internal parallelism, so the timeout applies to the
         // whole discovered suite rather than one file.
@@ -157,6 +160,7 @@ export class TestExecutionCoordinator extends BaseDomainCoordinator {
             return this.executeParallel({
                 testFiles: testsToRun,
                 framework,
+                frameworkFromConfig,
                 workers,
                 timeout,
                 retryCount: request.retryCount,
@@ -167,6 +171,7 @@ export class TestExecutionCoordinator extends BaseDomainCoordinator {
         return this.execute({
             testFiles: testsToRun,
             framework,
+            frameworkFromConfig,
             timeout,
             retryCount: request.retryCount,
             projectRoot: request.projectRoot,
@@ -198,9 +203,13 @@ export class TestExecutionCoordinator extends BaseDomainCoordinator {
         await this.executor.recordFinalOutcome(run, testFiles);
     }
     /**
-     * Detect test framework from file patterns and project configuration
+     * Fallback framework from file names. With no explicit framework, each
+     * runner project's own config still decides between jest and vitest (#1272),
+     * and Python files always run with pytest (#1248).
      */
     detectFramework(testFiles) {
+        if (testFiles.every(isPythonTestFile))
+            return 'pytest';
         // Check file patterns for common framework indicators
         const hasVitestPattern = testFiles.some(f => f.includes('.test.') || f.includes('.spec.'));
         const hasMochaPattern = testFiles.some(f => f.includes('_test.') || f.includes('.mocha.'));
@@ -209,7 +218,6 @@ export class TestExecutionCoordinator extends BaseDomainCoordinator {
             return 'vitest';
         if (hasMochaPattern)
             return 'mocha';
-        // Could add project config detection here (vitest.config.ts, jest.config.js, etc.)
         return 'vitest';
     }
     /**
@@ -299,7 +307,7 @@ export class TestExecutionCoordinator extends BaseDomainCoordinator {
                 if (this.config.infraHealing && result.value.failedTests.length > 0) {
                     this.feedInfraHealingFromFailures(result.value.failedTests);
                     // ADR-057: Attempt automatic recovery and re-run affected tests
-                    const rerunResult = await this.attemptAutoRecoveryAndRerun(result.value.failedTests, request.framework, { timeout: request.timeout, env: request.env, retryCount: request.retryCount, projectRoot: request.projectRoot });
+                    const rerunResult = await this.attemptAutoRecoveryAndRerun(result.value.failedTests, request.framework, { timeout: request.timeout, env: request.env, retryCount: request.retryCount, projectRoot: request.projectRoot, frameworkFromConfig: request.frameworkFromConfig });
                     if (rerunResult)
                         return rerunResult;
                 }
@@ -410,7 +418,7 @@ export class TestExecutionCoordinator extends BaseDomainCoordinator {
                 if (this.config.infraHealing && result.value.failedTests.length > 0) {
                     this.feedInfraHealingFromFailures(result.value.failedTests);
                     // ADR-057: Attempt automatic recovery and re-run affected tests
-                    const rerunResult = await this.attemptAutoRecoveryAndRerun(result.value.failedTests, request.framework, { timeout: request.timeout, env: request.env, retryCount: request.retryCount, projectRoot: request.projectRoot });
+                    const rerunResult = await this.attemptAutoRecoveryAndRerun(result.value.failedTests, request.framework, { timeout: request.timeout, env: request.env, retryCount: request.retryCount, projectRoot: request.projectRoot, frameworkFromConfig: request.frameworkFromConfig });
                     if (rerunResult)
                         return rerunResult;
                 }
@@ -631,6 +639,7 @@ export class TestExecutionCoordinator extends BaseDomainCoordinator {
         return this.execute({
             testFiles: [...filesToRerun],
             framework,
+            frameworkFromConfig: originalRequest.frameworkFromConfig,
             timeout: originalRequest.timeout,
             env: originalRequest.env,
             retryCount: originalRequest.retryCount,

package/dist/domains/test-execution/interfaces.d.ts

@@ -56,6 +56,11 @@ export interface ISimpleTestRequest {
 export interface IExecuteTestsRequest {
     testFiles: string[];
     framework: string;
+    /**
+     * #1272: the caller named no framework, so each runner project's own config
+     * chooses jest or vitest; `framework` is used where it names neither.
+     */
+    frameworkFromConfig?: boolean;
     timeout?: number;
     env?: Record<string, string>;
     reporters?: string[];

package/dist/domains/test-execution/plugin.js

@@ -80,6 +80,8 @@ export class TestExecutionPlugin extends BaseDomainPlugin {
                         // Simple request format
                         const request = {
                             testFiles,
+                            // #1272: an explicit framework wins over the project's config.
+                            framework: typeof payload.framework === 'string' ? payload.framework : undefined,
                             parallel: payload.parallel,
                             retryCount: payload.retryCount,
                             timeout: payload.timeout,

package/dist/domains/test-execution/services/flaky-detector.d.ts

@@ -39,7 +39,8 @@ export interface FlakyDetectorConfig {
      */
     testRunnerArgs: string[];
     /**
-     * Working directory for test execution.
+     * Working directory for test execution. When omitted, each file runs from
+     * its nearest runner project, as test_execute_parallel does (#1247, #1272).
      */
     cwd?: string;
     /**
@@ -112,6 +113,13 @@ export declare class FlakyDetectorService implements IFlakyTestDetector {
     /** Cache TTL for analysis results (1 hour) */
     private readonly ANALYSIS_CACHE_TTL_MS;
     constructor(memory: MemoryBackend, config?: Partial<FlakyDetectorConfig>);
+    /** True when the caller chose the runner command; else the project's config picks it. */
+    private readonly runnerConfigured;
+    /**
+     * #1272: the runner command for a run started in `cwd`. A configured command
+     * is used as given; the default runs Jest in a project configured for Jest.
+     */
+    private runnerCommandIn;
     /**
      * Detect flaky tests by running them multiple times
      */