canary-test-cli 6.6.0 → 6.7.0

package/dist/engine/core/migrator.js

@@ -37,11 +37,14 @@
  *   - Python truthiness (`""`/`None`/`{}`/`[]` falsy) via {@link pyTruthy}.
  */
 import { createHash } from 'node:crypto';
-import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync, } from 'node:fs';
+import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync, } from 'node:fs';
 import { homedir } from 'node:os';
 import { basename, isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { readJsonWithWarning } from './config-validation.js';
 import { uncertainDetectionMessage } from './detection.js';
+import { _CONFIG_PROBES, inferPlaywrightShape, probe, } from './framework-probes.js';
+import { comparePathParts, globDirs, globFiles, isDir, isFile, readTextOrNull, } from './fs-glob.js';
+import { detectWorkspace, workspaceGlobs, } from './workspace-detect.js';
 import { FrameworkRegistry } from './framework-registry.js';
 import { EXIT_ABSTAINED, gateOutcome } from './gate-result.js';
 import { Scaffolder, scaffoldableFrameworks, TEMPLATES } from './scaffolder.js';
@@ -80,29 +83,6 @@ const EMDASH = '\u{2014}'; // em dash
 // Lives beside the deployed skills; never a deployable skill itself (leading dot
 // -> skipped by the skill scanner).
 export const DEPLOY_MANIFEST_NAME = '.deploy-manifest.json';
-/**
- * Order two POSIX-style relative paths the way Python orders `Path` objects:
- * component-wise (`PurePath.__lt__` compares the parts list), NOT as joined
- * strings. They differ when a directory name prefixes a sibling file name and
- * the next char sorts below '/' (0x2F) -- most commonly the '.' extension
- * separator, e.g. `scripts/run.sh` vs `scripts.md`. A joined-string sort places
- * `scripts.md` first ('.' 0x2E < '/' 0x2F); Python's component sort places
- * `scripts/run.sh` first ('scripts' < 'scripts.md'). This ordering feeds the
- * skill-dir hash, a byte-exact contract compared against Python-written
- * .deploy-manifest.json files on the upgrade path.
- */
-function comparePathParts(a, b) {
-    const pa = a.split('/');
-    const pb = b.split('/');
-    const n = Math.min(pa.length, pb.length);
-    for (let i = 0; i < n; i++) {
-        if (pa[i] < pb[i])
-            return -1;
-        if (pa[i] > pb[i])
-            return 1;
-    }
-    return pa.length - pb.length;
-}
 /**
  * A stable sha256 of every file under *skillDir* (component-sorted rel-path +
  * bytes). Exported so a test can pin it byte-for-byte to the Python oracle:
@@ -293,64 +273,6 @@ const _DOC_SKILL_LAYER_NAMES = new Set([
     'commands',
     'prompts',
 ]);
-// (config_file, framework, shape, confidence)
-const _CONFIG_PROBES = [
-    ['playwright.config.ts', 'playwright', 'e2e_ui', 'config'],
-    ['playwright.config.js', 'playwright', 'e2e_ui', 'config'],
-    ['cypress.config.ts', 'playwright', 'e2e_ui', 'config'],
-    ['cypress.config.js', 'playwright', 'e2e_ui', 'config'],
-    ['vitest.config.ts', 'vitest', 'frontend_unit', 'config'],
-    ['vitest.config.js', 'vitest', 'frontend_unit', 'config'],
-    ['vitest.config.mts', 'vitest', 'frontend_unit', 'config'],
-    ['jest.config.ts', 'vitest', 'frontend_unit', 'config'],
-    ['jest.config.js', 'vitest', 'frontend_unit', 'config'],
-    ['jest.config.mjs', 'vitest', 'frontend_unit', 'config'],
-    ['k6.config.js', 'k6', 'performance', 'config'],
-    ['pytest.ini', 'pytest', 'api', 'config'],
-    ['setup.cfg', 'pytest', 'api', 'config'],
-    ['axe.config.js', 'axe-core', 'accessibility', 'config'],
-    ['backstop.json', 'backstopjs', 'visual', 'config'],
-    ['pact.json', 'pact', 'contract', 'config'],
-    ['.pact', 'pact', 'contract', 'config'],
-    ['stryker.config.js', 'stryker', 'mutation', 'config'],
-    ['stryker.config.mjs', 'stryker', 'mutation', 'config'],
-    ['locust.conf', 'locust', 'load', 'config'],
-    ['locustfile.py', 'locust', 'load', 'config'],
-    ['wdio.conf.ts', 'wdio', 'mobile', 'config'],
-    ['wdio.conf.js', 'wdio', 'mobile', 'config'],
-    ['wdio.conf.mjs', 'wdio', 'mobile', 'config'],
-];
-// pyproject.toml section markers
-const _PYPROJECT_MARKERS = [
-    ['[tool.pytest.ini_options]', 'pytest', 'api'],
-    ['[tool.coverage', 'pytest', 'api'],
-];
-// package.json test script -> (framework, shape)
-const _PACKAGE_SCRIPT_PATTERNS = [
-    [/\bplaywright\b/, 'playwright', 'e2e_ui'],
-    [/\bcypress\b/, 'playwright', 'e2e_ui'],
-    [/\bvitest\b/, 'vitest', 'frontend_unit'],
-    [/\bjest\b/, 'vitest', 'frontend_unit'],
-    [/\bk6\b/, 'k6', 'performance'],
-    [/\blocust\b/, 'locust', 'load'],
-    [/\bstryker\b/, 'stryker', 'mutation'],
-    [/\bwdio\b/, 'wdio', 'mobile'],
-];
-// Python dependency -> (framework, shape). MULTILINE `^` anchored on `\n` only.
-const _PYTHON_DEP_PATTERNS = [
-    [/(?:^|(?<=\n))pytest\b/i, 'pytest', 'api'],
-    [/(?:^|(?<=\n))locust\b/i, 'locust', 'load'],
-    [/(?:^|(?<=\n))pact\b/i, 'pact', 'contract'],
-    [/(?:^|(?<=\n))sdv\b/i, 'sdv', 'synthetic_data'],
-    [/(?:^|(?<=\n))faker\b/i, 'faker', 'synthetic_data'],
-    [/(?:^|(?<=\n))testcontainers\b/i, 'testcontainers', 'integration'],
-];
-// Language -> (framework, shape) fallbacks from harness.config.json
-const _LANGUAGE_FALLBACKS = {
-    python: ['pytest', 'api'],
-    typescript: ['playwright', 'e2e_ui'],
-    javascript: ['playwright', 'e2e_ui'],
-};
 const _TEST_GLOBS = [
     'tests/**/*.py',
     'test/**/*.py',
@@ -361,86 +283,62 @@ const _TEST_GLOBS = [
     'src/**/*.spec.ts',
     'src/**/*.test.ts',
 ];
-// Detects playwright UI fixture params. MULTILINE is a no-op (no `^`/`$`).
-const _PW_UI_FIXTURE_RE = /async\s*\(\s*\{[^}]*\b(?:page|browser)\b/;
-// ---------------------------------------------------------------------------
-// Small filesystem / glob helpers
-// ---------------------------------------------------------------------------
-function isDir(path) {
-    try {
-        return statSync(path).isDirectory();
-    }
-    catch {
-        return false;
-    }
-}
-function isFile(path) {
-    try {
-        return statSync(path).isFile();
-    }
-    catch {
-        return false;
+/**
+ * Suites for *framework* already present in this repo's workspace packages.
+ *
+ * The repo root is excluded on purpose: a root config is already reported via
+ * `skipped_configs`, and listing it here would double-count it and suppress a
+ * scaffold that the skip logic handles more precisely.
+ */
+function findWorkspaceSuites(root, framework) {
+    const globs = workspaceGlobs(root);
+    if (globs.length === 0)
+        return [];
+    const configNames = _CONFIG_PROBES
+        .filter(([, fw]) => fw === framework)
+        .map(([filename]) => filename);
+    if (configNames.length === 0)
+        return [];
+    const dirs = new Set();
+    for (const glob of globs)
+        for (const d of globDirs(root, glob))
+            dirs.add(d);
+    const suites = [];
+    for (const dir of [...dirs].sort(comparePathParts)) {
+        const config = configNames.find((name) => isFile(join(dir, name)));
+        if (config === undefined)
+            continue;
+        const tests = new Set();
+        for (const pattern of _TEST_GLOBS) {
+            for (const f of globFiles(dir, pattern))
+                tests.add(f);
+        }
+        suites.push({
+            dir: relative(root, dir).split(sep).join('/'),
+            config,
+            test_count: tests.size,
+        });
     }
-}
-/** Compile a single glob segment (with `*` -> `[^/]*`) to an anchored regex. */
-function segGlobRegex(seg) {
-    const body = seg
-        .replace(/[.+^${}()|[\]\\?]/g, '\\$&')
-        .replace(/\*/g, '[^/]*');
-    return new RegExp(`^${body}$`);
+    return suites;
 }
 /**
- * Match files under *root* against a pathlib-style glob (`**` matches zero or
- * more directories; `*` matches within a single segment). Mirrors the subset of
- * `Path.glob` the migrator needs.
+ * The shape implied by an explicit `--framework` override (#504 (2)).
+ *
+ * Reuses the probe table so the override resolves exactly the shape a matching
+ * config file would have, including the playwright api-vs-UI refinement.
+ * Returns null for a framework no probe knows, so the caller keeps whatever
+ * shape detection produced rather than overwriting it with a guess.
  */
-function globFiles(root, pattern) {
-    const segments = pattern.split('/');
-    const out = [];
-    const visit = (dir, si) => {
-        const seg = segments[si];
-        const last = si === segments.length - 1;
-        if (seg === '**') {
-            // `**` consumes zero directories -> continue at the same dir.
-            visit(dir, si + 1);
-            // `**` consumes one-or-more -> descend into each subdir, staying on `**`.
-            for (const d of subDirs(dir))
-                visit(d, si);
-            return;
-        }
-        const re = segGlobRegex(seg);
-        let entries;
-        try {
-            entries = readdirSync(dir, { withFileTypes: true });
-        }
-        catch {
-            return;
+function shapeForFrameworkOverride(framework, root) {
+    for (const [, probeFramework, shape] of _CONFIG_PROBES) {
+        if (probeFramework !== framework)
+            continue;
+        if (probeFramework === 'playwright' && shape === 'e2e_ui') {
+            return inferPlaywrightShape(root);
         }
-        for (const e of entries) {
-            if (!re.test(e.name))
-                continue;
-            const full = join(dir, e.name);
-            if (last) {
-                if (e.isFile() || isFile(full))
-                    out.push(full);
-            }
-            else if (e.isDirectory()) {
-                visit(full, si + 1);
-            }
-        }
-    };
-    visit(root, 0);
-    return out;
-}
-function subDirs(dir) {
-    try {
-        return readdirSync(dir, { withFileTypes: true })
-            .filter((e) => e.isDirectory())
-            .map((e) => join(dir, e.name));
-    }
-    catch {
-        return [];
+        return shape;
     }
+    return null;
 }
 /**
  * Return a human reason when *config* describes a skills/docs overlay (not a
@@ -476,6 +374,23 @@ function skillsDocsOverlayReason(config) {
         `${sortedNames}), not a test suite. \`canary migrate\` ` +
         'scaffolds a test suite and has nothing to migrate here.');
 }
+/**
+ * The deduplicated, sorted union of the root shape and every package's shape.
+ *
+ * `unknown` is excluded: it is the absence of a shape, and carrying it into a
+ * union that drives deployment would let "we could not tell" masquerade as a
+ * detected shape. An empty array therefore means nothing was detected (#504).
+ */
+function unionShapes(rootShape, ws) {
+    const shapes = new Set();
+    if (rootShape !== 'unknown' && rootShape !== '')
+        shapes.add(rootShape);
+    for (const f of ws?.findings ?? []) {
+        if (f.shape !== 'unknown' && f.shape !== '')
+            shapes.add(f.shape);
+    }
+    return [...shapes].sort();
+}
 export class MigrationContext {
     project_root;
     is_harness_project;
@@ -487,6 +402,21 @@ export class MigrationContext {
     detection_confidence;
     config_warnings;
     not_test_project_reason;
+    /**
+     * Declared workspace topology, or null for a single-package repo.
+     *
+     * Null is the back-compatibility guarantee -- a repo that declares no
+     * workspace never enters the plural path (#504 part 1).
+     */
+    workspace;
+    /**
+     * Every shape detected anywhere, deduplicated and sorted.
+     *
+     * Populated but not yet read: plural deployment is Milestone 2. Landing the
+     * data first keeps this change reviewable as "detection got richer, nothing
+     * else moved" (#504 part 1).
+     */
+    shapes;
     constructor(init) {
         this.project_root = init.project_root;
         this.is_harness_project = init.is_harness_project;
@@ -497,6 +427,8 @@ export class MigrationContext {
         this.detection_confidence = init.detection_confidence ?? 'none';
         this.config_warnings = init.config_warnings ?? [];
         this.not_test_project_reason = init.not_test_project_reason ?? null;
+        this.workspace = init.workspace ?? null;
+        this.shapes = init.shapes ?? [];
     }
 }
 export class SkillDeployResult {
@@ -735,10 +667,16 @@ export class MigrationReport {
     skipped_configs;
     preserved_files;
     would_create;
+    /** Suites already present in workspace packages (#504 (3)). */
+    existing_suites;
     manual_followups;
     deployed_skills;
     installed_workflows;
     config_warnings;
+    /** Declared workspace topology, or null for a single-package repo (#504). */
+    workspace;
+    /** Every detected shape, deduplicated and sorted; unread until Milestone 2. */
+    shapes;
     constructor(init) {
         this.framework = init.framework;
         this.shape = init.shape;
@@ -750,10 +688,39 @@ export class MigrationReport {
         this.skipped_configs = init.skipped_configs ?? [];
         this.preserved_files = init.preserved_files ?? [];
         this.would_create = init.would_create ?? [];
+        this.existing_suites = init.existing_suites ?? [];
         this.manual_followups = init.manual_followups ?? [];
         this.deployed_skills = init.deployed_skills ?? [];
         this.installed_workflows = init.installed_workflows ?? [];
         this.config_warnings = init.config_warnings ?? [];
+        this.workspace = init.workspace ?? null;
+        this.shapes = init.shapes ?? [];
+    }
+    /**
+     * What the workspace walk actually covered, stated with its denominator.
+     *
+     * Emitted only when a workspace was declared, so single-package output is
+     * untouched. Saying "0 packages carry a test config" is a different claim
+     * from saying nothing at all, which reads as "there was nothing to find"
+     * (#504 part 1, criteria 4 and 5).
+     */
+    workspaceNotes() {
+        const ws = this.workspace;
+        if (ws === null)
+            return [];
+        const notes = [];
+        if (ws.globs.length > 0 && ws.scanned === 0) {
+            const g = ws.globs.length === 1 ? '1 glob' : `${ws.globs.length} globs`;
+            notes.push(`Declared ${g}, matched 0 packages.`);
+        }
+        else if (ws.scanned > 0 && ws.findings.length === 0) {
+            const p = ws.scanned === 1 ? '1 package' : `${ws.scanned} packages`;
+            notes.push(`${p} scanned, none carries a recognizable test config.`);
+        }
+        for (const dir of ws.unreadable) {
+            notes.push(`\`${dir}/\` could not be read and was not scanned.`);
+        }
+        return notes;
     }
     /**
      * The dry run's denominator (#504): config files that would be created,
@@ -787,10 +754,28 @@ export class MigrationReport {
                 config: `high ${EMDASH} dedicated config file`,
                 content: `medium ${EMDASH} file content / dependency scan`,
                 language: `low ${EMDASH} harness.config.json language fallback`,
+                override: `high ${EMDASH} explicit \`--framework\` flag`,
             }[this.detection_confidence] ?? this.detection_confidence;
             lines.push(`**Detected from:** \`${this.detection_source}\``, `**Confidence:** ${confidenceLabel}`);
         }
         lines.push('');
+        const wsNotes = this.workspaceNotes();
+        if (wsNotes.length > 0) {
+            lines.push('## Workspace', '');
+            for (const n of wsNotes)
+                lines.push(`- ${n}`);
+            lines.push('');
+        }
+        // #504 (3): name what was found before saying what would happen, so the
+        // empty "Would Create" below reads as a decision rather than a shrug.
+        if (this.existing_suites.length > 0) {
+            lines.push('## Existing Suites Found', '');
+            for (const s of this.existing_suites) {
+                const tests = s.test_count === 1 ? '1 test file' : `${s.test_count} test files`;
+                lines.push(`- \`${s.dir}/\` ${EMDASH} \`${s.config}\` (${tests})`);
+            }
+            lines.push('');
+        }
         if (this.dry_run) {
             if (this.preserved_files.length > 0) {
                 lines.push('## Existing Tests (will be preserved)', '');
@@ -804,6 +789,12 @@ export class MigrationReport {
                     lines.push(`- \`${f}\``);
                 lines.push('');
             }
+            else if (this.existing_suites.length > 0) {
+                const names = this.existing_suites.map((s) => `\`${s.dir}/\``);
+                lines.push('## Would Create', '', `_Nothing ${EMDASH} ${names.join(', ')} already ` +
+                    `carries a ${this.framework} suite. To scaffold a second one, ` +
+                    're-run `canary migrate` from inside that package._', '');
+            }
             else {
                 lines.push('## Would Create', '', '_Nothing new ' +
                     EMDASH +
@@ -880,11 +871,17 @@ export class MigrationReport {
             });
             lines.push('## Status', '');
             if (outcome.abstained) {
-                lines.push(outcome.summaryLine, '', 'This dry run would migrate zero item(s) ' +
-                    EMDASH +
-                    ' the project already carries everything this migration would ' +
-                    'produce. If you expected changes, check `--from <overlay>` and ' +
-                    'the detected framework/shape above.', '');
+                // Zero is zero either way, but *why* differs: an already-complete
+                // project and a repo whose suite lives in a package are different
+                // situations, and the generic sentence misdescribes the second.
+                const why = this.existing_suites.length > 0
+                    ? 'the suite this migration would scaffold already exists in ' +
+                        `${this.existing_suites.map((s) => `\`${s.dir}/\``).join(', ')}. ` +
+                        'Re-run `canary migrate` from inside that package to migrate it.'
+                    : 'the project already carries everything this migration would ' +
+                        'produce. If you expected changes, check `--from <overlay>` and ' +
+                        'the detected framework/shape above.';
+                lines.push(outcome.summaryLine, '', `This dry run would migrate zero item(s) ${EMDASH} ${why}`, '');
             }
             else {
                 lines.push(`Dry run ${EMDASH} would migrate ${n} item(s). ` +
@@ -946,7 +943,10 @@ export class HarnessMigrator {
                 not_test_project_reason: overlayReason,
             });
         }
-        const [framework, shape, source, confidence] = this.detectFramework(projectRoot, harnessConfig);
+        // Detected once and threaded: `detectFramework` resolves the scalar from it
+        // and the context carries it, so the package walk happens a single time.
+        const workspace = detectWorkspace(projectRoot, harnessConfig, configWarnings);
+        const [framework, shape, source, confidence] = this.detectFramework(projectRoot, harnessConfig, workspace);
         return new MigrationContext({
             project_root: projectRoot,
             is_harness_project: true,
@@ -956,6 +956,8 @@ export class HarnessMigrator {
             detection_source: source,
             detection_confidence: confidence,
             config_warnings: configWarnings,
+            workspace,
+            shapes: unionShapes(shape, workspace),
         });
     }
     migrate(projectRoot, options = {}) {
@@ -973,11 +975,25 @@ export class HarnessMigrator {
         const effectiveFramework = pyTruthy(framework)
             ? framework
             : ctx.detected_framework;
-        const shape = ctx.detected_shape;
         const source = pyTruthy(framework) ? 'CLI override' : ctx.detection_source;
+        // #504 (2): an override is high-confidence *user intent*, not a config-file
+        // find. Reporting it as 'config' rendered "high -- dedicated config file",
+        // asserting evidence no probe ever gathered.
         const confidence = pyTruthy(framework)
-            ? 'config'
+            ? 'override'
             : ctx.detection_confidence;
+        // #504 (2): the override must resolve the shape too. Without this, shape
+        // stays 'unknown' and every shape-keyed behavior downstream (overlay-skill
+        // matching, `<shape>:`-prefixed workflow templates) silently no-ops, so the
+        // override only half-works. An explicit `canary_shape` is a stronger
+        // statement of intent than the framework name, so it still wins.
+        const explicitShape = String(ctx.harness_config['canary_shape'] ?? '')
+            .trim()
+            .toLowerCase();
+        const overrideShape = pyTruthy(framework) && explicitShape === ''
+            ? shapeForFrameworkOverride(framework, projectRoot)
+            : null;
+        const shape = overrideShape ?? ctx.detected_shape;
         const followups = [];
         if (effectiveFramework === null) {
             followups.push(uncertainDetectionMessage('test framework', {
@@ -997,6 +1013,8 @@ export class HarnessMigrator {
                 detection_confidence: confidence,
                 manual_followups: followups,
                 config_warnings: ctx.config_warnings,
+                workspace: ctx.workspace,
+                shapes: ctx.shapes,
                 deployed_skills: deployed,
                 installed_workflows: this.installWorkflows(shape, overlayPath, projectRoot, dryRun, force),
             });
@@ -1013,6 +1031,9 @@ export class HarnessMigrator {
                 `scaffolded; set it up manually.${run}`);
         }
         const preserved = this.findExistingTests(projectRoot);
+        // #504 (3): a workspace repo that already has a suite for this framework
+        // must not be offered a second one at the root.
+        const existingSuites = findWorkspaceSuites(projectRoot, effectiveFramework);
         const scaffolder = new Scaffolder();
         const deployed = this.deploySkills(shape, overlayPath, projectRoot, dryRun);
         // Post-copy install phase: the template bytes already landed under
@@ -1022,10 +1043,14 @@ export class HarnessMigrator {
             const tmpl = TEMPLATES[effectiveFramework];
             const files = tmpl?.files ?? {};
             const dirs = tmpl?.dirs ?? [];
-            const wouldCreate = [
-                ...Object.keys(files).filter((f) => !existsSync(join(projectRoot, f))),
-                ...dirs.filter((d) => !existsSync(join(projectRoot, d))),
-            ];
+            // A suite already exists in a package: propose nothing rather than a
+            // duplicate. The suites are named in the report so the zero is legible.
+            const wouldCreate = existingSuites.length > 0
+                ? []
+                : [
+                    ...Object.keys(files).filter((f) => !existsSync(join(projectRoot, f))),
+                    ...dirs.filter((d) => !existsSync(join(projectRoot, d))),
+                ];
             const alreadyPresent = Object.keys(files).filter((f) => existsSync(join(projectRoot, f)));
             return new MigrationReport({
                 framework: effectiveFramework,
@@ -1036,19 +1061,28 @@ export class HarnessMigrator {
                 would_create: wouldCreate,
                 skipped_configs: alreadyPresent,
                 preserved_files: preserved,
+                existing_suites: existingSuites,
                 manual_followups: followups,
                 deployed_skills: deployed,
                 installed_workflows: installedWorkflows,
                 config_warnings: ctx.config_warnings,
+                workspace: ctx.workspace,
+                shapes: ctx.shapes,
             });
         }
-        const result = scaffolder.scaffold(effectiveFramework, String(projectRoot));
+        // Same guard on the apply path: what the dry run refuses to propose, an
+        // `--apply` run must refuse to write. Skills and workflows still deploy --
+        // only the duplicate test-config scaffold is withheld.
+        const result = existingSuites.length > 0
+            ? { created_files: [], created_dirs: [], skipped_files: [] }
+            : scaffolder.scaffold(effectiveFramework, String(projectRoot));
         return new MigrationReport({
             framework: effectiveFramework,
             shape,
             dry_run: false,
             detection_source: source,
             detection_confidence: confidence,
+            existing_suites: existingSuites,
             created_files: result['created_files'],
             created_dirs: result['created_dirs'],
             skipped_configs: result['skipped_files'],
@@ -1057,6 +1091,8 @@ export class HarnessMigrator {
             deployed_skills: deployed,
             installed_workflows: installedWorkflows,
             config_warnings: ctx.config_warnings,
+            workspace: ctx.workspace,
+            shapes: ctx.shapes,
         });
     }
     // -- private helpers --------------------------------------------------------
@@ -1328,7 +1364,7 @@ export class HarnessMigrator {
         // writes. Informational only -- see FreshnessReport.workflows.
         this.installWorkflows(shape, overlayPath, projectRoot, true, false));
     }
-    detectFramework(root, config) {
+    detectFramework(root, config, ws = null) {
         // Explicit override in .canary/company.json ("canary_shape" field) is
         // user intent: it wins over every probe tier's shape, including a total
         // probe miss (#502 — monorepos often have no root framework config).
@@ -1338,94 +1374,47 @@ export class HarnessMigrator {
         const explicitShape = (rawShape == null ? '' : String(rawShape))
             .trim()
             .toLowerCase();
-        const [framework, shape, source, confidence] = this.probeFramework(root, config);
+        const rootProbe = this.probeFramework(root, config);
+        // A root miss falls through to the workspace packages -- but only a miss.
+        // A root config file still outranks them, unchanged from before (#504).
+        const resolved = rootProbe[0] === null && ws !== null
+            ? (this.resolveFromWorkspace(ws) ?? rootProbe)
+            : rootProbe;
+        const [framework, shape, source, confidence] = resolved;
         if (!explicitShape)
             return [framework, shape, source, confidence];
         return framework === null
             ? [null, explicitShape, 'canary_shape (.canary/company.json)', 'explicit']
             : [framework, explicitShape, source, confidence];
     }
-    probeFramework(root, config) {
-        // 1. Dedicated config file (highest confidence).
-        for (const [filename, framework, shape, confidence] of _CONFIG_PROBES) {
-            if (existsSync(join(root, filename))) {
-                // For playwright config files, distinguish API vs UI suites.
-                if (framework === 'playwright' && shape === 'e2e_ui') {
-                    const inferred = inferPlaywrightShape(root);
-                    if (inferred !== shape)
-                        return [framework, inferred, filename, 'content'];
-                }
-                return [framework, shape, filename, confidence];
-            }
-        }
-        // 2. pyproject.toml section markers then dependency scan.
-        const pyproject = join(root, 'pyproject.toml');
-        if (existsSync(pyproject)) {
-            const content = readTextOrNull(pyproject);
-            if (content !== null) {
-                for (const [marker, framework, shape] of _PYPROJECT_MARKERS) {
-                    if (content.includes(marker)) {
-                        return [framework, shape, 'pyproject.toml', 'content'];
-                    }
-                }
-                for (const [pattern, framework, shape] of _PYTHON_DEP_PATTERNS) {
-                    if (pattern.test(content)) {
-                        return [
-                            framework,
-                            shape,
-                            'pyproject.toml (dependencies)',
-                            'content',
-                        ];
-                    }
-                }
-            }
-        }
-        // 3. requirements*.txt dependency scan.
-        for (const reqFile of [
-            'requirements.txt',
-            'requirements-test.txt',
-            'requirements-dev.txt',
-        ]) {
-            const reqPath = join(root, reqFile);
-            if (existsSync(reqPath)) {
-                const content = readTextOrNull(reqPath);
-                if (content !== null) {
-                    for (const [pattern, framework, shape] of _PYTHON_DEP_PATTERNS) {
-                        if (pattern.test(content))
-                            return [framework, shape, reqFile, 'content'];
-                    }
-                }
-            }
-        }
-        // 4. package.json scripts.test scan.
-        const pkgJson = join(root, 'package.json');
-        if (existsSync(pkgJson)) {
-            try {
-                const pkg = JSON.parse(readFileSync(pkgJson, 'utf-8'));
-                const scripts = (pkg['scripts'] ?? {});
-                const testScript = String(scripts['test'] ?? '');
-                for (const [pattern, framework, shape] of _PACKAGE_SCRIPT_PATTERNS) {
-                    if (pattern.test(testScript)) {
-                        return [framework, shape, 'package.json (scripts.test)', 'content'];
-                    }
-                }
-            }
-            catch {
-                // OSError / JSONDecodeError -> ignore.
-            }
-        }
-        // 5. Language fallback from harness config.
-        const language = String(config['language'] ?? '').toLowerCase();
-        if (Object.prototype.hasOwnProperty.call(_LANGUAGE_FALLBACKS, language)) {
-            const [fw, shape] = _LANGUAGE_FALLBACKS[language];
-            return [
-                fw,
-                shape,
-                `harness.config.json (language: ${language})`,
-                'language',
-            ];
+    /**
+     * The scalar (framework, shape, source) implied by workspace findings.
+     *
+     * Unanimity is on the (framework, shape) PAIR, not the framework alone --
+     * shape drives which overlay skills and workflow templates deploy, so two
+     * playwright packages resolving to e2e_ui and api are not unanimous. Applies
+     * at N >= 1: `detection_source` reports the package count, so the scalar
+     * never pretends a root probe hit (#504 part 1).
+     */
+    resolveFromWorkspace(ws) {
+        const findings = ws.findings;
+        if (findings.length === 0)
+            return null;
+        const pairs = new Set(findings.map((f) => `${f.framework}${f.shape}`));
+        if (pairs.size > 1) {
+            return [null, 'unknown', 'workspace (mixed)', 'none'];
         }
-        return [null, 'unknown', 'none', 'none'];
+        const first = findings[0];
+        const n = new Set(findings.map((f) => f.dir)).size;
+        return [
+            first.framework,
+            first.shape,
+            `workspace (${n} package${n === 1 ? '' : 's'})`,
+            first.confidence,
+        ];
+    }
+    probeFramework(root, config) {
+        return probe(root, config, ['config', 'content', 'language']);
     }
     findExistingTests(root) {
         const found = [];
@@ -1441,42 +1430,4 @@ export class HarnessMigrator {
         return found;
     }
 }
-function readTextOrNull(path) {
-    try {
-        return readFileSync(path, 'utf-8');
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Return 'api' when no playwright spec file uses page/browser fixtures, else
- * 'e2e_ui' (the default when any UI signal is found or no spec files exist).
- */
-function inferPlaywrightShape(root) {
-    const specGlobs = [
-        'tests/**/*.spec.ts',
-        'tests/**/*.spec.js',
-        'test/**/*.spec.ts',
-        'test/**/*.spec.js',
-    ];
-    let total = 0;
-    for (const glob of specGlobs) {
-        for (const path of globFiles(root, glob)) {
-            // Python read_text(errors="ignore"); readFileSync substitutes U+FFFD for
-            // invalid bytes -- immaterial for the ASCII fixture pattern below.
-            let content;
-            try {
-                content = readFileSync(path, 'utf-8');
-            }
-            catch {
-                continue;
-            }
-            total += 1;
-            if (_PW_UI_FIXTURE_RE.test(content))
-                return 'e2e_ui';
-        }
-    }
-    return total > 0 ? 'api' : 'e2e_ui';
-}
 //# sourceMappingURL=migrator.js.map