agentic-workflow-manager 6.5.2 → 8.0.0

package/dist/tests/commands/preflight/preflight.test.js

@@ -47,56 +47,56 @@ const make = (o) => { const d = project(o); dirs.push(d); return d; };
 afterAll(() => dirs.forEach(d => fs_1.default.rmSync(d, { recursive: true, force: true })));
 const check = (r, id) => r.checks.find(c => c.id === id);
 describe('preflight', () => {
-    it('reports not_configured when no sensor manifest exists', () => {
+    it('reports not_configured when no sensor manifest exists', async () => {
         // The team-rollout case: a developer clones the repo and never runs
         // `awm sensors init`. Today nothing notices until an unattended run is already
         // in flight and every quality phase is consuming a gate that certifies nothing.
         const dir = make();
-        const report = (0, checks_1.preflight)(dir);
+        const report = await (0, checks_1.preflight)(dir);
         expect(report.status).toBe('not_configured');
         expect(check(report, 'manifest').ok).toBe(false);
     });
-    it('keeps not_configured and degraded apart', () => {
+    it('keeps not_configured and degraded apart', async () => {
         // "You never set this up" and "you set it up and it broke" need different
         // remedies. Collapsing them is how an absent check reads as a passing one.
         const never = make();
         const broken = make({
             manifest: { pack: 'js-ts', sensors: { lint: { cmd: 'npx eslint .' } } }, // no local eslint
         });
-        expect((0, checks_1.preflight)(never).status).toBe('not_configured');
-        expect((0, checks_1.preflight)(broken).status).toBe('degraded');
+        expect((await (0, checks_1.preflight)(never)).status).toBe('not_configured');
+        expect((await (0, checks_1.preflight)(broken)).status).toBe('degraded');
     });
-    it('is ready when the declared sensors can actually run', () => {
+    it('is ready when the declared sensors can actually run', async () => {
         const dir = make({
             manifest: { pack: 'js-ts', sensors: { lint: { cmd: 'npx eslint .' } } },
             bins: ['eslint'],
             files: ['package.json'],
         });
-        const report = (0, checks_1.preflight)(dir);
+        const report = await (0, checks_1.preflight)(dir);
         expect(report.status).toBe('ready');
         expect((0, preflight_1.exitCodeFor)(report)).toBe(0);
     });
-    it('catches a sensor whose tool is not installed locally', () => {
+    it('catches a sensor whose tool is not installed locally', async () => {
         // This is the check that existed and nothing in the flow was calling.
         const dir = make({
             manifest: { pack: 'js-ts', sensors: { lint: { cmd: 'npx eslint .' } } },
             files: ['package.json'],
         });
-        const report = (0, checks_1.preflight)(dir);
+        const report = await (0, checks_1.preflight)(dir);
         expect(report.status).toBe('degraded');
         expect(check(report, 'tools').detail).toContain('eslint');
     });
-    it('accepts a deliberate opt-out, but only when it is written down', () => {
+    it('accepts a deliberate opt-out, but only when it is written down', async () => {
         // A repo may legitimately have no sensors — it just has to SAY so in a committed
         // file, so "we decided not to gate this" cannot be mistaken for "nobody set it up".
         const optedOut = make({
             manifest: { pack: 'generic', sensors: { security: { cmd: 'semgrep .', enabled: false } } },
         });
-        const report = (0, checks_1.preflight)(optedOut);
+        const report = await (0, checks_1.preflight)(optedOut);
         expect(report.status).toBe('ready');
         expect(check(report, 'manifest').detail).toContain('opt-out');
     });
-    it('flags a manifest with zero sensor entries as degraded, distinct from a deliberate opt-out', () => {
+    it('flags a manifest with zero sensor entries as degraded, distinct from a deliberate opt-out', async () => {
         // Genuinely different manifest shape from the opt-out test above: no sensor
         // NAMES at all, vs. an opt-out which lists every known sensor explicitly with
         // `enabled: false`. This is the honest-floor case from init.ts — the registry
@@ -104,14 +104,14 @@ describe('preflight', () => {
         const noPack = make({
             manifest: { pack: 'python', sensors: {} },
         });
-        const report = (0, checks_1.preflight)(noPack);
+        const report = await (0, checks_1.preflight)(noPack);
         expect(report.status).toBe('degraded');
         expect(check(report, 'manifest').ok).toBe(false);
         expect(check(report, 'manifest').detail).not.toContain('opt-out');
         expect(check(report, 'manifest').detail).toContain('python');
         expect(check(report, 'manifest').remedy).toContain('python');
     });
-    it('flags the tools check as failing (not "0/0 runnable") for a manifest with zero sensor entries', () => {
+    it('flags the tools check as failing (not "0/0 runnable") for a manifest with zero sensor entries', async () => {
         // Regression for Finding 6: `checkTools` independently inspects
         // `status.checks`, which is also `{}` for a zero-sensor manifest —
         // `Object.entries({}).filter(...)` is vacuously `[]`, so before the fix this
@@ -122,34 +122,34 @@ describe('preflight', () => {
         const noPack = make({
             manifest: { pack: 'python', sensors: {} },
         });
-        const report = (0, checks_1.preflight)(noPack);
+        const report = await (0, checks_1.preflight)(noPack);
         expect(check(report, 'tools').ok).toBe(false);
         expect(report.status).toBe('degraded');
     });
-    it('flags a manifest stuck on generic while the tree has a real stack', () => {
+    it('flags a manifest stuck on generic while the tree has a real stack', async () => {
         // The gate would run, report green, and have checked almost nothing.
         const dir = make({
             manifest: { pack: 'generic', sensors: {} },
             files: ['package.json'],
         });
-        const report = (0, checks_1.preflight)(dir);
+        const report = await (0, checks_1.preflight)(dir);
         expect(report.status).toBe('degraded');
         expect(check(report, 'pack').ok).toBe(false);
     });
-    it('flags a repo with no context contract at all', () => {
+    it('flags a repo with no context contract at all', async () => {
         const dir = make({
             context: [],
             manifest: { pack: 'generic', sensors: {} },
         });
-        expect(check((0, checks_1.preflight)(dir), 'context').ok).toBe(false);
+        expect(check(await (0, checks_1.preflight)(dir), 'context').ok).toBe(false);
     });
-    it('treats an unparseable manifest as a failure, not as absent', () => {
+    it('treats an unparseable manifest as a failure, not as absent', async () => {
         const dir = make({ manifest: '{ not json' });
-        const report = (0, checks_1.preflight)(dir);
+        const report = await (0, checks_1.preflight)(dir);
         expect(report.status).toBe('degraded');
         expect(check(report, 'manifest').detail).toContain('not valid JSON');
     });
-    it('exits non-zero for anything but ready, so the caller need not parse JSON', () => {
+    it('exits non-zero for anything but ready, so the caller need not parse JSON', async () => {
         // Unlike `awm sensors run` — which exits 0 on not_certified because exit 2 blocks
         // Claude Code hooks — preflight is never a hook, so the verdict rides the exit code
         // instead of depending on every agent remembering to read a field.
@@ -187,74 +187,74 @@ describe('preflight', () => {
             fs_1.default.writeFileSync(f, '#!/bin/sh\nexit 0\n');
             fs_1.default.chmodSync(f, 0o755);
         }
-        it('reports github + gh available, and does not affect status', () => {
+        it('reports github + gh available, and does not affect status', async () => {
             const dir = make({ manifest: { pack: 'generic', sensors: { security: { enabled: false } } } });
             gitRepo(dir, 'git@github.com:kodria/agentic-workflow.git');
             installOnPath('gh');
-            const report = (0, checks_1.preflight)(dir);
+            const report = await (0, checks_1.preflight)(dir);
             expect(check(report, 'host').ok).toBe(true);
             expect(check(report, 'host').detail).toBe('github detected, gh available');
             expect(report.status).toBe('ready');
         });
-        it('is still ok:true (advisory only) when gitlab is detected but glab is not on PATH, and status stays ready', () => {
+        it('is still ok:true (advisory only) when gitlab is detected but glab is not on PATH, and status stays ready', async () => {
             // The only thing "wrong" in this fixture is the missing `glab` — proving the
             // advisory contract: it must not drag an otherwise-clean repo to `degraded`.
             const dir = make({ manifest: { pack: 'generic', sensors: { security: { enabled: false } } } });
             gitRepo(dir, 'https://gitlab.com/kodria/agentic-workflow.git');
             // PATH aislado y vacio => glab no resuelve.
-            const report = (0, checks_1.preflight)(dir);
+            const report = await (0, checks_1.preflight)(dir);
             expect(check(report, 'host').ok).toBe(true);
             expect(check(report, 'host').detail).toContain('glab not on PATH');
             expect(check(report, 'host').remedy).toContain('glab');
             expect(report.status).toBe('ready');
         });
-        it('handles no origin remote gracefully — no throw, ok:true, minimal detail', () => {
+        it('handles no origin remote gracefully — no throw, ok:true, minimal detail', async () => {
             const dir = make({ manifest: { pack: 'generic', sensors: { security: { enabled: false } } } });
             // Not a git repo at all — the common case for `execFileSync` failing here.
-            const report = (0, checks_1.preflight)(dir);
+            const report = await (0, checks_1.preflight)(dir);
             expect(check(report, 'host').ok).toBe(true);
             expect(check(report, 'host').detail).toBe('no git remote detected — PR/MR automation not applicable');
             expect(check(report, 'host').remedy).toBeUndefined();
             expect(report.status).toBe('ready');
         });
-        it('handles a git repo with no origin remote configured gracefully', () => {
+        it('handles a git repo with no origin remote configured gracefully', async () => {
             const dir = make({ manifest: { pack: 'generic', sensors: { security: { enabled: false } } } });
             gitRepo(dir); // git init, no remote
-            const report = (0, checks_1.preflight)(dir);
+            const report = await (0, checks_1.preflight)(dir);
             expect(check(report, 'host').ok).toBe(true);
             expect(check(report, 'host').detail).toContain('no git remote detected');
         });
-        it('does not overclaim support for an unrecognized host', () => {
+        it('does not overclaim support for an unrecognized host', async () => {
             const dir = make({ manifest: { pack: 'generic', sensors: { security: { enabled: false } } } });
             gitRepo(dir, 'git@bitbucket.org:kodria/agentic-workflow.git');
-            const report = (0, checks_1.preflight)(dir);
+            const report = await (0, checks_1.preflight)(dir);
             expect(check(report, 'host').ok).toBe(true);
             expect(check(report, 'host').detail).toContain('not recognized');
             expect(report.status).toBe('ready');
         });
-        it('does not misclassify a GitHub Enterprise host whose repo NAME contains "gitlab"', () => {
+        it('does not misclassify a GitHub Enterprise host whose repo NAME contains "gitlab"', async () => {
             // The bug: a bare `remote.includes('gitlab')` matches the full remote URL
             // string, so an org/repo name containing "gitlab" false-positives even though
             // the actual host is unrelated. Hostname must be extracted first and matched
             // in isolation.
             const dir = make({ manifest: { pack: 'generic', sensors: { security: { enabled: false } } } });
             gitRepo(dir, 'git@github.enterprise.internal:kodria/gitlab-migration-tool.git');
-            const report = (0, checks_1.preflight)(dir);
+            const report = await (0, checks_1.preflight)(dir);
             expect(check(report, 'host').ok).toBe(true);
             expect(check(report, 'host').detail).toContain('not recognized');
             expect(report.status).toBe('ready');
         });
-        it('does not misclassify a non-GitHub host whose repo NAME contains "github"', () => {
+        it('does not misclassify a non-GitHub host whose repo NAME contains "github"', async () => {
             // Same class of bug on the github side: "something-github-tool" is a repo
             // name, not the host.
             const dir = make({ manifest: { pack: 'generic', sensors: { security: { enabled: false } } } });
             gitRepo(dir, 'https://example.com/kodria/something-github-tool.git');
-            const report = (0, checks_1.preflight)(dir);
+            const report = await (0, checks_1.preflight)(dir);
             expect(check(report, 'host').ok).toBe(true);
             expect(check(report, 'host').detail).toContain('not recognized');
             expect(report.status).toBe('ready');
         });
-        it('does not misclassify a GitHub Enterprise host whose SSH USERNAME is "gitlab"', () => {
+        it('does not misclassify a GitHub Enterprise host whose SSH USERNAME is "gitlab"', async () => {
             // The related bug: the scheme-based regex captured everything between
             // `scheme://` and the first `/`, including `userinfo@` — so an SSH username
             // of "gitlab" leaked into the matched "host" string and false-positived the
@@ -269,25 +269,25 @@ describe('preflight', () => {
             const dir = make({ manifest: { pack: 'generic', sensors: { security: { enabled: false } } } });
             gitRepo(dir, 'ssh://gitlab@github.company-internal.com:22/team/repo.git');
             // PATH real: estos casos no dependen de gh/glab.
-            const report = (0, checks_1.preflight)(dir);
+            const report = await (0, checks_1.preflight)(dir);
             expect(check(report, 'host').ok).toBe(true);
             expect(check(report, 'host').detail).toContain('github detected');
             expect(check(report, 'host').detail).not.toContain('gitlab');
             expect(report.status).toBe('ready');
         });
-        it('does not misclassify a host whose injected credential/token contains "gitlab"', () => {
+        it('does not misclassify a host whose injected credential/token contains "gitlab"', async () => {
             // A realistic CI credential-injection remote:
             // `git remote set-url origin https://x-access-token:$TOKEN@host/...`. If the
             // token or password happens to contain "gitlab", it must not leak into the
             // matched host either.
             const dir = make({ manifest: { pack: 'generic', sensors: { security: { enabled: false } } } });
             gitRepo(dir, 'https://user:gitlab@example-host.com/org/repo.git');
-            const report = (0, checks_1.preflight)(dir);
+            const report = await (0, checks_1.preflight)(dir);
             expect(check(report, 'host').ok).toBe(true);
             expect(check(report, 'host').detail).toContain('not recognized');
             expect(report.status).toBe('ready');
         });
-        it('does not misclassify an SCP-style remote with a second "@" in it', () => {
+        it('does not misclassify an SCP-style remote with a second "@" in it', async () => {
             // `user@host:path` shorthand has no scheme for `URL` to parse, so it falls
             // back to a regex. A second "@" (e.g. a malformed/adversarial remote) must
             // not let a bogus "host@evil"-shaped capture slip past the colon check —
@@ -295,42 +295,42 @@ describe('preflight', () => {
             // falls through to "unrecognized" rather than misclassifying as gitlab.
             const dir = make({ manifest: { pack: 'generic', sensors: { security: { enabled: false } } } });
             gitRepo(dir, 'user@github.com@gitlab.evil:org/repo.git');
-            const report = (0, checks_1.preflight)(dir);
+            const report = await (0, checks_1.preflight)(dir);
             expect(check(report, 'host').ok).toBe(true);
             expect(check(report, 'host').detail).toContain('not recognized');
             expect(report.status).toBe('ready');
         });
-        it('still detects github.com over HTTPS', () => {
+        it('still detects github.com over HTTPS', async () => {
             const dir = make({ manifest: { pack: 'generic', sensors: { security: { enabled: false } } } });
             gitRepo(dir, 'https://github.com/org/repo.git');
             // PATH real: estos casos no dependen de gh/glab.
-            const report = (0, checks_1.preflight)(dir);
+            const report = await (0, checks_1.preflight)(dir);
             expect(check(report, 'host').detail).toContain('github detected');
         });
-        it('still detects github.com over SSH shorthand', () => {
+        it('still detects github.com over SSH shorthand', async () => {
             const dir = make({ manifest: { pack: 'generic', sensors: { security: { enabled: false } } } });
             gitRepo(dir, 'git@github.com:org/repo.git');
             // PATH real: estos casos no dependen de gh/glab.
-            const report = (0, checks_1.preflight)(dir);
+            const report = await (0, checks_1.preflight)(dir);
             expect(check(report, 'host').detail).toContain('github detected');
         });
-        it('still detects gitlab over HTTPS', () => {
+        it('still detects gitlab over HTTPS', async () => {
             const dir = make({ manifest: { pack: 'generic', sensors: { security: { enabled: false } } } });
             gitRepo(dir, 'https://gitlab.example.com/org/repo.git');
             // PATH real: estos casos no dependen de gh/glab.
-            const report = (0, checks_1.preflight)(dir);
+            const report = await (0, checks_1.preflight)(dir);
             expect(check(report, 'host').detail).toContain('gitlab detected');
         });
-        it('still detects gitlab over SSH shorthand', () => {
+        it('still detects gitlab over SSH shorthand', async () => {
             const dir = make({ manifest: { pack: 'generic', sensors: { security: { enabled: false } } } });
             gitRepo(dir, 'git@gitlab.example.com:org/repo.git');
             // PATH real: estos casos no dependen de gh/glab.
-            const report = (0, checks_1.preflight)(dir);
+            const report = await (0, checks_1.preflight)(dir);
             expect(check(report, 'host').detail).toContain('gitlab detected');
         });
     });
     describe('sensors-baseline check (advisory — never changes the exit code)', () => {
-        it('nudges toward `awm sensors baseline` when sensors are configured but no baseline exists', () => {
+        it('nudges toward `awm sensors baseline` when sensors are configured but no baseline exists', async () => {
             // The team-rollout gap this addresses: a legacy repo adopts AWM, sensors get
             // configured, and the ratchet mechanism exists to snapshot pre-existing debt —
             // but nothing tells the operator it's there until they hit a wall of red
@@ -340,13 +340,13 @@ describe('preflight', () => {
                 bins: ['eslint'],
                 files: ['package.json'],
             });
-            const report = (0, checks_1.preflight)(dir);
+            const report = await (0, checks_1.preflight)(dir);
             expect(check(report, 'sensors-baseline').ok).toBe(true);
             expect(check(report, 'sensors-baseline').detail).toContain('no baseline yet');
             expect(check(report, 'sensors-baseline').remedy).toContain('awm sensors baseline');
             expect(report.status).toBe('ready');
         });
-        it('reports the no-advisory-needed state when a baseline already exists, without nudging', () => {
+        it('reports the no-advisory-needed state when a baseline already exists, without nudging', async () => {
             const dir = make({
                 manifest: { pack: 'js-ts', sensors: { lint: { cmd: 'npx eslint .' } } },
                 bins: ['eslint'],
@@ -354,19 +354,19 @@ describe('preflight', () => {
             });
             fs_1.default.mkdirSync(path_1.default.join(dir, '.awm'), { recursive: true });
             fs_1.default.writeFileSync(path_1.default.join(dir, '.awm', 'sensors.baseline.json'), JSON.stringify({ lint: [] }));
-            const report = (0, checks_1.preflight)(dir);
+            const report = await (0, checks_1.preflight)(dir);
             expect(check(report, 'sensors-baseline').ok).toBe(true);
             expect(check(report, 'sensors-baseline').detail).toBe('baseline present');
             expect(check(report, 'sensors-baseline').remedy).toBeUndefined();
             expect(report.status).toBe('ready');
         });
-        it('is omitted entirely when there is no manifest at all — nothing to baseline without sensors', () => {
+        it('is omitted entirely when there is no manifest at all — nothing to baseline without sensors', async () => {
             const dir = make();
-            const report = (0, checks_1.preflight)(dir);
+            const report = await (0, checks_1.preflight)(dir);
             expect(report.checks.find(c => c.id === 'sensors-baseline')).toBeUndefined();
             expect(report.status).toBe('not_configured');
         });
-        it('does not nudge on a deliberate opt-out (every sensor disabled) — nothing to baseline', () => {
+        it('does not nudge on a deliberate opt-out (every sensor disabled) — nothing to baseline', async () => {
             // Regression: the trigger condition originally checked only manifestExists, so a
             // repo that deliberately opted out (checkManifest's own documented pattern: every
             // sensor `enabled: false`) still got told to run `awm sensors baseline` — nothing
@@ -374,19 +374,19 @@ describe('preflight', () => {
             const dir = make({
                 manifest: { pack: 'js-ts', sensors: { lint: { cmd: 'npx eslint .', enabled: false } } },
             });
-            const report = (0, checks_1.preflight)(dir);
+            const report = await (0, checks_1.preflight)(dir);
             expect(check(report, 'sensors-baseline').ok).toBe(true);
             expect(check(report, 'sensors-baseline').detail).toBe('no enabled sensors — nothing to baseline');
             expect(check(report, 'sensors-baseline').remedy).toBeUndefined();
         });
-        it('does not nudge on an unparseable manifest — nothing to baseline', () => {
+        it('does not nudge on an unparseable manifest — nothing to baseline', async () => {
             const dir = make({ manifest: '{not valid json' });
-            const report = (0, checks_1.preflight)(dir);
+            const report = await (0, checks_1.preflight)(dir);
             expect(check(report, 'sensors-baseline').ok).toBe(true);
             expect(check(report, 'sensors-baseline').detail).toBe('no enabled sensors — nothing to baseline');
             expect(check(report, 'sensors-baseline').remedy).toBeUndefined();
         });
-        it('still nudges when the baseline path exists but is not a readable file (e.g. a stray directory)', () => {
+        it('still nudges when the baseline path exists but is not a readable file (e.g. a stray directory)', async () => {
             // Regression: checking presence via `fs.existsSync` alone would have reported
             // "baseline present" here, reassuring the operator that debt is suppressed —
             // but the real gate (`readBaseline`, used by `partition()`) treats an unreadable
@@ -398,13 +398,13 @@ describe('preflight', () => {
                 files: ['package.json'],
             });
             fs_1.default.mkdirSync(path_1.default.join(dir, '.awm', 'sensors.baseline.json'), { recursive: true });
-            const report = (0, checks_1.preflight)(dir);
+            const report = await (0, checks_1.preflight)(dir);
             expect(check(report, 'sensors-baseline').ok).toBe(true);
             expect(check(report, 'sensors-baseline').detail).toContain('no baseline yet');
             expect(check(report, 'sensors-baseline').remedy).toContain('awm sensors baseline');
         });
     });
-    it('tells the operator not to hand a broken harness to an unattended run', () => {
+    it('tells the operator not to hand a broken harness to an unattended run', async () => {
         const out = (0, preflight_1.formatReport)({
             status: 'not_configured',
             checks: [{ id: 'manifest', ok: false, detail: 'no .awm/sensors.json', remedy: 'run `awm sensors init`' }],
@@ -412,7 +412,7 @@ describe('preflight', () => {
         expect(out).toContain('unattended');
         expect(out).toContain('awm sensors init');
     });
-    it('pads the id column to the widest id actually present, not a hardcoded width', () => {
+    it('pads the id column to the widest id actually present, not a hardcoded width', async () => {
         // Regression: a literal `.padEnd(9)` silently misaligned once `sensors-baseline`
         // (16 chars) was added as a check id — every detail column shifted left of where
         // shorter ids' details landed. The width must be derived from the report itself.

package/dist/tests/commands/registry/add.test.js

@@ -12,9 +12,24 @@ const GIT = (cwd, cmd) => (0, child_process_1.execSync)(`git -c user.email=t@t.t
 function makeSourceRepo(base, opts) {
     const dir = path_1.default.join(base, `src-${opts.skill ?? 'empty'}`);
     fs_1.default.mkdirSync(dir, { recursive: true });
-    if (!opts.empty && opts.skill) {
+    if (opts.contentSymlink) {
+        fs_1.default.symlinkSync(opts.contentSymlink, path_1.default.join(dir, 'skills'));
+    }
+    else if (opts.contentFile) {
+        fs_1.default.writeFileSync(path_1.default.join(dir, opts.contentFile), 'not a content directory');
+    }
+    else if (opts.nestedHookSymlink) {
+        fs_1.default.mkdirSync(path_1.default.join(dir, 'hooks'), { recursive: true });
+        fs_1.default.symlinkSync(opts.nestedHookSymlink, path_1.default.join(dir, 'hooks', 'session-start'));
+    }
+    else if (!opts.empty && opts.skill) {
         fs_1.default.mkdirSync(path_1.default.join(dir, 'skills', opts.skill), { recursive: true });
-        fs_1.default.writeFileSync(path_1.default.join(dir, 'skills', opts.skill, 'SKILL.md'), `---\nname: ${opts.skill}\ndescription: d\n---\n`);
+        if (opts.nestedSkillSymlink) {
+            fs_1.default.symlinkSync(opts.nestedSkillSymlink, path_1.default.join(dir, 'skills', opts.skill, 'SKILL.md'));
+        }
+        else {
+            fs_1.default.writeFileSync(path_1.default.join(dir, 'skills', opts.skill, 'SKILL.md'), `---\nname: ${opts.skill}\ndescription: d\n---\n`);
+        }
     }
     else {
         fs_1.default.writeFileSync(path_1.default.join(dir, 'README.md'), 'no content dirs');
@@ -97,6 +112,48 @@ describe('addRegistry', () => {
         expect(readRegistriesConfig()).toEqual([]);
         expect(fs_1.default.existsSync(path_1.default.join(tmpHome, '.awm/registries/bad'))).toBe(false);
     });
+    it('rejects a regular file that masquerades as a content directory', async () => {
+        const source = makeSourceRepo(tmpWork, { contentFile: 'skills' });
+        const { addRegistry } = require('../../../src/commands/registry/add');
+        const result = await addRegistry(source, 'not-a-registry');
+        expect(result.ok).toBe(false);
+        expect(result.error).toMatch(/skills\/, bundles\/, workflows\/, agents\//);
+        const { readRegistriesConfig } = require('../../../src/core/registries');
+        expect(readRegistriesConfig()).toEqual([]);
+        expect(fs_1.default.existsSync(path_1.default.join(tmpHome, '.awm/registries/not-a-registry'))).toBe(false);
+    });
+    it('rejects a symlink that masquerades as a content directory', async () => {
+        const source = makeSourceRepo(tmpWork, { contentSymlink: '.' });
+        const { addRegistry } = require('../../../src/commands/registry/add');
+        const result = await addRegistry(source, 'linked-content');
+        expect(result.ok).toBe(false);
+        expect(result.error).toMatch(/skills\/, bundles\/, workflows\/, agents\//);
+        const { readRegistriesConfig } = require('../../../src/core/registries');
+        expect(readRegistriesConfig()).toEqual([]);
+        expect(fs_1.default.existsSync(path_1.default.join(tmpHome, '.awm/registries/linked-content'))).toBe(false);
+    });
+    it('rejects a nested artifact symlink before discovery can read it', async () => {
+        const outside = path_1.default.join(tmpWork, 'outside-skill.md');
+        fs_1.default.writeFileSync(outside, 'host-only content');
+        const source = makeSourceRepo(tmpWork, { skill: 'linked', nestedSkillSymlink: outside });
+        const { addRegistry } = require('../../../src/commands/registry/add');
+        const result = await addRegistry(source, 'nested-link');
+        expect(result.ok).toBe(false);
+        const { readRegistriesConfig } = require('../../../src/core/registries');
+        expect(readRegistriesConfig()).toEqual([]);
+        expect(fs_1.default.existsSync(path_1.default.join(tmpHome, '.awm/registries/nested-link'))).toBe(false);
+    });
+    it('rejects a nested hook symlink before capability consumers can use it', async () => {
+        const outside = path_1.default.join(tmpWork, 'outside-hook');
+        fs_1.default.writeFileSync(outside, 'host-only content');
+        const source = makeSourceRepo(tmpWork, { nestedHookSymlink: outside });
+        const { addRegistry } = require('../../../src/commands/registry/add');
+        const result = await addRegistry(source, 'nested-hook-link');
+        expect(result.ok).toBe(false);
+        const { readRegistriesConfig } = require('../../../src/core/registries');
+        expect(readRegistriesConfig()).toEqual([]);
+        expect(fs_1.default.existsSync(path_1.default.join(tmpHome, '.awm/registries/nested-hook-link'))).toBe(false);
+    });
     it('is atomic: artifact collision with existing configured registry → no config, cleanup, error names both', async () => {
         // First registry already registered with the 'alpha' skill
         const source1 = path_1.default.join(tmpWork, 'src-alpha-1');
@@ -133,6 +190,16 @@ describe('addRegistry', () => {
         const { readRegistriesConfig } = require('../../../src/core/registries');
         expect(readRegistriesConfig()).toEqual([]);
     });
+    it.each(['', '..', 'bad..name', 'a/b', 'a\\b'])('rejects unsafe registry name %s without cloning or writing config', async (name) => {
+        const source = makeSourceRepo(tmpWork, { skill: 'alpha' });
+        const { addRegistry } = require('../../../src/commands/registry/add');
+        const result = await addRegistry(source, name);
+        expect(result.ok).toBe(false);
+        expect(result.error).toMatch(/Invalid registry name/);
+        const { readRegistriesConfig } = require('../../../src/core/registries');
+        expect(readRegistriesConfig()).toEqual([]);
+        expect(fs_1.default.existsSync(path_1.default.join(tmpHome, '.awm/registries', name))).toBe(false);
+    });
     it('rejects duplicate registry name and clone failure without writing config', async () => {
         const source = makeSourceRepo(tmpWork, { skill: 'alpha' });
         const { addRegistry } = require('../../../src/commands/registry/add');

package/dist/tests/commands/registry/status.test.js

@@ -40,4 +40,18 @@ describe('registry override status', () => {
         const { overrideStatus } = require('../../../src/commands/registry/status');
         expect(overrideStatus(team, [])).toEqual([]);
     });
+    it('registry list delegates discovery eligibility to the validated-roots guard', () => {
+        const source = fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../../../src/commands/registry/index.ts'), 'utf8');
+        expect(source).toContain('const safeRoots = new Set(contentRoots());');
+        expect(source).toContain('if (!canDiscoverRegistryContent(r.contentRoot, safeRoots))');
+    });
+    it('prevents discovery when a registry root was excluded from validated roots', () => {
+        const { canDiscoverRegistryContent } = require('../../../src/commands/registry/status');
+        expect(canDiscoverRegistryContent('/unsafe/registry', new Set())).toBe(false);
+        expect(canDiscoverRegistryContent('/safe/registry', new Set(['/safe/registry']))).toBe(true);
+    });
+    it('registry list gives a recoverable instruction for an unsafe existing registry', () => {
+        const source = fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../../../src/commands/registry/index.ts'), 'utf8');
+        expect(source).toContain("unsafe layout — remove the registry and add it again");
+    });
 });

package/dist/tests/commands/sensors/compatibility/contract.test.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const contract_1 = require("../../../../src/commands/sensors/compatibility/contract");
+const coverage = {
+    schemaVersion: 1,
+    classes: {
+        formatting: {
+            description: 'Formatting is checked.',
+            detectors: [{ sensor: 'lint' }],
+            remedy: { summary: 'Add a formatter.', command: 'npm install prettier' },
+        },
+    },
+};
+function validPack() {
+    return {
+        schemaVersion: 2,
+        name: 'js-ts', description: 'fixture', detects: ['package.json'],
+        sensors: {
+            lint: {
+                applicability: { allFiles: ['package.json'] },
+                variants: [{
+                        id: 'eslint-9',
+                        priority: 10,
+                        requirements: { tool: 'eslint', toolRange: '>=9.0.0 <10.0.0', runtime: 'node', runtimeRange: '>=20.0.0' },
+                        certifiedRange: '>=9.0.0 <10.0.0',
+                        assets: ['eslint.config.awm.mjs'], formatter: 'eslint-llm', probe: { kind: 'eslint-print-config' },
+                        command: {
+                            executable: 'eslint',
+                            resolution: 'node-modules-bin',
+                            args: ['--format', 'json', '{files}'],
+                            fileInput: { placeholder: '{files}', extensions: ['.ts', '.tsx'] },
+                        },
+                    }],
+            },
+        },
+        coverage,
+    };
+}
+describe('sensor pack v2 contract', () => {
+    it('parses a valid versioned pack', () => {
+        expect((0, contract_1.parseSensorPack)(validPack(), 'pack.json')).toMatchObject({ kind: 'v2', pack: validPack() });
+    });
+    it('keeps an unversioned pack on the legacy compatibility path', () => {
+        const legacy = { name: 'legacy', sensors: {} };
+        expect((0, contract_1.parseSensorPack)(legacy, 'pack.json')).toMatchObject({ kind: 'legacy', pack: { ...legacy, compatibility: { state: 'compatible-unverified' } } });
+    });
+    test.each([
+        [{ name: 'legacy', detects: [null], sensors: {} }, 'detects[0]'],
+        [{ name: 'legacy', detects: ['package.json'], sensors: { lint: { unknown: true } } }, 'unknown field'],
+        [{ name: 'legacy', detects: ['package.json'], sensors: { lint: { defaultCmd: 'eslint\u0000 .' } } }, 'defaultCmd'],
+        [{ name: 'legacy', detects: ['package.json'], sensors: { lint: { changedExtensions: ['.ts', 3] } } }, 'changedExtensions[1]'],
+        [{ name: 'legacy', detects: ['package.json'], sensors: { 'bad/name': {} } }, 'sensor id'],
+    ])('rejects recursively malformed legacy content %j', (input, message) => {
+        expect(() => (0, contract_1.parseSensorPack)(input, 'legacy-pack.json')).toThrow(message);
+    });
+    it('preserves legacy config file fallbacks', () => {
+        expect((0, contract_1.parseSensorPack)({ name: 'legacy', sensors: { lint: { configFile: 'eslint.config.js', configFileFallback: '.eslintrc.json' } } }, 'legacy')).toMatchObject({ kind: 'legacy', pack: { sensors: { lint: { configFile: 'eslint.config.js', configFileFallback: '.eslintrc.json' } } } });
+    });
+    it('rejects malformed applicability and probe extensions', () => {
+        const variant = validPack().sensors.lint.variants[0];
+        expect(() => (0, contract_1.parseSensorPack)({ ...validPack(), sensors: { lint: { applicability: { allFiles: [3] }, variants: [variant] } } }, 'pack')).toThrow('allFiles[0]');
+        expect(() => (0, contract_1.parseSensorPack)({ ...validPack(), sensors: { lint: { ...validPack().sensors.lint, variants: [{ ...variant, probe: { kind: 'version', extra: true } }] } } }, 'pack')).toThrow('unknown field');
+    });
+    it('preserves configFiles and rejects incomplete public overlap input', () => {
+        const variant = { ...validPack().sensors.lint.variants[0], requirements: { ...validPack().sensors.lint.variants[0].requirements, configFiles: ['eslint.config.js'] } };
+        expect((0, contract_1.parseSensorPack)({ ...validPack(), sensors: { lint: { ...validPack().sensors.lint, variants: [variant] } } }, 'pack')).toMatchObject({ kind: 'v2', pack: { sensors: { lint: { variants: [{ requirements: { configFiles: ['eslint.config.js'] } }] } } } });
+        const complete = validPack().sensors.lint.variants[0];
+        expect(() => (0, contract_1.assertNoEqualPriorityOverlap)([{ ...complete, id: '../bad' }])).toThrow('stable lowercase id');
+        expect(() => (0, contract_1.assertNoEqualPriorityOverlap)([{ ...complete, command: undefined }])).toThrow('command');
+    });
+    it('rejects equal-priority variants with overlapping operational tool ranges', () => {
+        const first = validPack().sensors.lint.variants[0];
+        const second = { ...first, id: 'eslint-9-alt', certifiedRange: '>=10 <11', requirements: { ...first.requirements, toolRange: '>=9.5 <10.5' } };
+        expect(() => (0, contract_1.assertNoEqualPriorityOverlap)([first, second])).toThrow('overlap');
+    });
+    it('accepts overlapping tool ranges when runtime ranges are disjoint', () => {
+        const first = validPack().sensors.lint.variants[0];
+        const second = { ...first, id: 'eslint-9-node-old', requirements: { ...first.requirements, toolRange: '>=9.5 <10.5', runtimeRange: '>=18 <20' } };
+        expect(() => (0, contract_1.assertNoEqualPriorityOverlap)([first, second])).not.toThrow();
+    });
+    test.each([
+        [{ ...validPack(), schemaVersion: 3 }, 'supported: legacy, 2'],
+        [{ ...validPack(), sensors: { lint: { variants: [] } } }, 'variants'],
+        [{ ...validPack(), name: '../escape' }, 'name'],
+        [{ ...validPack(), sensors: { lint: { ...validPack().sensors.lint, variants: [{ ...validPack().sensors.lint.variants[0], assets: ['../secret'] }] } } }, 'asset'],
+        [{ ...validPack(), sensors: { lint: { variants: [{ ...validPack().sensors.lint.variants[0], command: { executable: 'sh', resolution: 'path', args: ['-c', 'echo nope'] } }] } } }, 'executable'],
+        [{ ...validPack(), coverage: { ...coverage, schemaVersion: 2 } }, 'coverage.schemaVersion'],
+        [{ ...validPack(), sensors: { lint: { variants: [{ ...validPack().sensors.lint.variants[0], certifiedRange: 'not-a-range' }] } } }, 'certifiedRange'],
+        [{ ...validPack(), sensors: { lint: validPack().sensors.lint, lint2: validPack().sensors.lint } }, 'variant id'],
+        [{ ...validPack(), sensors: { lint: { variants: [validPack().sensors.lint.variants[0], { ...validPack().sensors.lint.variants[0], id: 'eslint-9-next', certifiedRange: '>=9.1.0 <10.0.0' }] } } }, 'overlap'],
+        [{ ...validPack(), sensors: { lint: { ...validPack().sensors.lint, variants: [{ ...validPack().sensors.lint.variants[0], assets: ['C:/secret'] }] } } }, 'asset'],
+        [{ ...validPack(), sensors: { lint: { ...validPack().sensors.lint, variants: [{ ...validPack().sensors.lint.variants[0], command: { executable: 'cmd.exe', resolution: 'path', args: ['x'] } }] } } }, 'executable'],
+        [{ ...validPack(), sensors: { lint: { ...validPack().sensors.lint, variants: [{ ...validPack().sensors.lint.variants[0], command: { ...validPack().sensors.lint.variants[0].command, args: ['prefix{files}'] } }] } } }, 'embed'],
+        [{ ...validPack(), sensors: { lint: { ...validPack().sensors.lint, variants: [{ ...validPack().sensors.lint.variants[0], formatter: 'bad\nformat' }] } } }, 'formatter'],
+    ])('rejects malformed pack %j', (input, message) => {
+        expect(() => (0, contract_1.parseSensorPack)(input, 'pack.json')).toThrow(message);
+    });
+});