simple-skills-manager 1.0.1

package/tests/smoke-extension.ts

@@ -0,0 +1,577 @@
+/**
+ * simple-skills-manager smoke suite (phase 1). Runs inside `pi -e` with
+ * PI_SKILL_FIXTURES pointing at tests/fixtures and PI_SKILL_RESULT naming
+ * the output JSON. No external model, no untrusted network calls — local
+ * fixtures and temp dirs only.
+ *
+ * Covers: both transports end-to-end (discovery, grouping, script flagging,
+ * hidden skills, rejections), the frontmatter subset, validation
+ * invariants, config round-trips, the production executor path (lazy scan,
+ * success, reuse, fail-closed drift), native mirror computation, and the
+ * regression suites (name-length invariants, malformed-manifest safety,
+ * scan-budget enforcement, pathological sources).
+ */
+
+import { createHash } from "node:crypto";
+import { cp, mkdir, mkdtemp, readFile, rm, symlink, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { getAgentDir, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import {
+    buildManagedSkillExecutor,
+    createScanCache,
+    piSkillToolName,
+} from "../index.ts";
+import {
+    computeExposedSkills,
+    DEFAULT_SETTINGS,
+    fingerprint,
+    loadManagerConfig,
+    manifestSkills,
+    removeRootEntry,
+    saveManagerConfig,
+    selectedSkills,
+    skillGroup,
+    skillFilePath,
+    upsertRoot,
+    validateManifest,
+    validateRoot,
+    type ManagerSettings,
+    type RootConfig,
+    type SkillSnapshot,
+} from "../config.ts";
+import { parseFrontmatter, scanRoot, snapshotSkillFile, copyTreeInto } from "../scan.ts";
+import { buildTreeRows, visibleRows } from "../menu.ts";
+
+const FIXTURES = process.env.PI_SKILL_FIXTURES!;
+const RESULT = process.env.PI_SKILL_RESULT!;
+
+function assert(condition: unknown, message: string): void {
+    if (!condition) throw new Error(`assertion failed: ${message}`);
+}
+
+async function tempDir(prefix: string): Promise<string> {
+    return await mkdtemp(join(tmpdir(), prefix));
+}
+
+function hashFile(bytes: Buffer): string {
+    return createHash("sha256").update(bytes).digest("hex");
+}
+
+// ─── 1. Scans ───────────────────────────────────────────────────────────────
+
+async function scanSuite(settings: ManagerSettings): Promise<Record<string, unknown>> {
+    // skills-dir: nested groups, scripts, hidden, duplicates.
+    const dirRoot: RootConfig = {
+        name: "fixture-dir", enabled: false, transport: "skills-dir",
+        path: join(FIXTURES, "skills-dir"), connection: "lazy",
+        skills: { mode: "selected", include: [] },
+    };
+    const outcome = await scanRoot(dirRoot, process.cwd(), settings);
+    const names = outcome.skills.map((skill) => skill.name);
+    assert(JSON.stringify(names) === JSON.stringify(["doc-skill", "dupe", "hidden-skill", "plain-skill", "scripted-skill"]), `skills-dir names wrong: ${names}`);
+    const byName = new Map(outcome.skills.map((skill) => [skill.name, skill]));
+    assert(byName.get("doc-skill")!.dirPath === "grouped/doc", "doc-skill dirPath wrong");
+    assert(skillGroup(byName.get("doc-skill")!.dirPath) === "grouped", "grouped group wrong");
+    assert(skillGroup(byName.get("plain-skill")!.dirPath) === "ungrouped", "ungrouped group wrong");
+    const scripted = byName.get("scripted-skill")!;
+    assert(scripted.executableScripts.some((script) => script === "grouped/scripted/scripts/run.sh"), `script flagging wrong: ${scripted.executableScripts}`);
+    assert(scripted.fileCount >= 2, "scripted fileCount wrong");
+    assert(byName.get("hidden-skill")!.hidden === true, "hidden flag not detected");
+    assert(byName.get("plain-skill")!.hidden !== true, "plain skill wrongly hidden");
+    // contentHash matches the bytes on disk.
+    const plainBytes = await readFile(join(FIXTURES, "skills-dir/plain/SKILL.md"));
+    assert(byName.get("plain-skill")!.contentHash === hashFile(plainBytes), "contentHash does not match file bytes");
+    // Duplicates: first wins, second rejected with a readable reason.
+    assert(outcome.rejected.length === 1 && outcome.rejected[0]!.reason.includes("duplicate"), `duplicate handling wrong: ${JSON.stringify(outcome.rejected)}`);
+
+    // single-skill: one skill, inventory includes the reference file.
+    const soloRoot: RootConfig = {
+        name: "fixture-solo", enabled: false, transport: "single-skill",
+        path: join(FIXTURES, "single-skill"), connection: "lazy",
+        skills: { mode: "selected", include: [] },
+    };
+    const solo = await scanRoot(soloRoot, process.cwd(), settings);
+    assert(solo.skills.length === 1 && solo.skills[0]!.name === "solo-skill", "single-skill scan wrong");
+    assert(solo.skills[0]!.dirPath === ".", "single-skill dirPath wrong");
+    assert(solo.skills[0]!.fileCount >= 2, "single-skill inventory wrong");
+
+    // bad root: strict rejections (pi would load these leniently or warn).
+    const badRoot: RootConfig = {
+        name: "fixture-bad", enabled: false, transport: "skills-dir",
+        path: join(FIXTURES, "bad"), connection: "lazy",
+        skills: { mode: "selected", include: [] },
+    };
+    const bad = await scanRoot(badRoot, process.cwd(), settings);
+    assert(bad.skills.length === 0, `bad root produced skills: ${bad.skills.map((s) => s.name)}`);
+    assert(bad.rejected.length === 2, `bad root rejections wrong: ${JSON.stringify(bad.rejected)}`);
+    assert(bad.rejected.some((entry) => entry.reason.includes("description")), "malformed rejection reason wrong");
+    assert(bad.rejected.some((entry) => entry.reason.includes("frontmatter")), "unparseable rejection reason wrong");
+
+    // A symlinked root fails closed.
+    const linkDir = await tempDir("skill-scan-link-");
+    const target = join(FIXTURES, "single-skill");
+    const link = join(linkDir, "link");
+    await symlink(target, link);
+    let symlinkRejected = false;
+    try {
+        await scanRoot({ ...soloRoot, path: link }, process.cwd(), settings);
+    } catch (error) {
+        symlinkRejected = String(error).includes("symbolic link");
+    }
+    assert(symlinkRejected, "symlinked root was scanned");
+
+    // snapshotSkillFile preserves a root-level .md skill's instruction file
+    // name (an edit must not silently fall back to SKILL.md).
+    const soloMdPath = join(FIXTURES, "single-skill", "SKILL.md");
+    const soloSnap = await snapshotSkillFile(soloMdPath, ".", settings, "notes.md");
+    assert(soloSnap.file === "notes.md", `snapshotSkillFile lost the file name: ${soloSnap.file}`);
+    assert((await snapshotSkillFile(soloMdPath, ".", settings)).file !== "notes.md", "snapshotSkillFile must default the file to undefined");
+
+    // copyTreeInto's budget counts every filesystem entry, not just
+    // directories — a flat directory of many files must fail closed.
+    const copyDir = await tempDir("skill-smoke-copy-");
+    const flatSource = join(copyDir, "src");
+    await mkdir(flatSource, { recursive: true });
+    for (let i = 0; i < 12; i++) await writeFile(join(flatSource, `f${i}.txt`), "x");
+    let copyBudgetThrew = false;
+    try {
+        await copyTreeInto(flatSource, join(copyDir, "dst"), { ...settings, maxScanFiles: 10 });
+    } catch (error) {
+        copyBudgetThrew = String(error).includes("more than 10");
+    }
+    assert(copyBudgetThrew, "copyTreeInto did not enforce the entry budget against files");
+
+    return { skillsDir: true, singleSkill: true, strictRejections: true, symlinkRoots: true, snapshotFile: true, copyBudget: true };
+}
+
+// ─── 2. Frontmatter subset ─────────────────────────────────────────────────
+
+function frontmatterSuite(): boolean {
+    const good = parseFrontmatter('---\nname: x\ndescription: "Quoted: with colon" # trailing\n# comment\nunknown: ignored\n---\nbody');
+    assert(good.data?.["name"] === "x" && good.data?.["description"] === "Quoted: with colon", `good frontmatter wrong: ${JSON.stringify(good)}`);
+    const block = parseFrontmatter("---\nname: x\ndescription: |\n  block\n---\n");
+    assert(block.data === null && block.error?.includes("block scalar"), "block scalar must fail");
+    const unclosed = parseFrontmatter("---\nname: x\n");
+    assert(unclosed.data === null && unclosed.error?.includes("closed"), "unclosed fence must fail");
+    const none = parseFrontmatter("# no frontmatter\n");
+    assert(none.data === null, "missing frontmatter must fail");
+    return true;
+}
+
+// ─── 3. Validation invariants ───────────────────────────────────────────────
+
+function validationSuite(): boolean {
+    const base: RootConfig = {
+        name: "ok-root", enabled: false, transport: "skills-dir",
+        path: "/tmp/definitely-not-used", connection: "lazy",
+        skills: { mode: "selected", include: [] },
+    };
+    const unsafe: RootConfig[] = [
+        { ...base, name: "Bad_Name" },
+        { ...base, native: true },                                       // native flag on a non-native path
+        { ...base, store: true },                                        // store flag on a non-store path
+        { ...base, skills: { mode: "all", include: ["x"] } },
+        { ...base, skills: { mode: "selected", include: ["x", "x"] } },
+        { ...base, path: "bad\u0000path" },
+        { ...base, name: "a".repeat(49) },
+    ];
+    for (const config of unsafe) {
+        const issues = validateRoot(config);
+        assert(issues.length > 0, `unsafe config accepted: ${JSON.stringify({ name: config.name, issues })}`);
+    }
+    // Manifest binding: valid for its own identity, invalid for a different path.
+    const root: RootConfig = { ...base, path: "/tmp/alpha" };
+    const manifest = { version: 1 as const, fingerprint: fingerprint(root), scannedAt: "t", skills: [snapshotStub()] };
+    assert(validateManifest(manifest, root).manifest, "manifest rejected for its own root");
+    assert(!validateManifest(manifest, { ...root, path: "/tmp/beta" }).manifest, "manifest accepted for a different root");
+    // A selected skill absent from the manifest is an issue.
+    assert(!validateManifest(manifest, { ...root, skills: { mode: "selected", include: ["absent"] } }).manifest, "absent selected skill accepted");
+    // Bad content hashes, names, and dir paths are rejected.
+    const badSnapshots = [
+        { ...snapshotStub(), contentHash: "nothex" },
+        { ...snapshotStub(), name: "Bad Name" },
+        { ...snapshotStub(), dirPath: "../escape" },
+        { ...snapshotStub(), dirPath: "/absolute" },
+        { ...snapshotStub(), description: "" },
+    ];
+    for (const snapshot of badSnapshots) {
+        const checked = validateManifest({ ...manifest, skills: [snapshot] }, root);
+        assert(!checked.manifest, `malformed snapshot accepted: ${JSON.stringify(snapshot).slice(0, 120)}`);
+    }
+    return true;
+}
+
+function snapshotStub(): SkillSnapshot {
+    return {
+        name: "stub-skill",
+        description: "Stub skill for manifest tests.",
+        dirPath: "stub-skill",
+        contentHash: "a".repeat(64),
+        fileCount: 1,
+        executableScripts: [],
+    };
+}
+
+// ─── 4. Config round-trip ──────────────────────────────────────────────────
+
+async function configRoundTrip(): Promise<Record<string, unknown>> {
+    const dir = await tempDir("skill-smoke-cfg-");
+    const path = join(dir, "config.json");
+
+    // First load auto-creates the starter, seeded with the store root.
+    // (Auto-detected native roots may also appear — machine-dependent; every
+    // assertion below is tolerant of them.)
+    const first = await loadManagerConfig(path);
+    assert(first.created, "first-run starter was not created");
+    assert(first.roots.filter((root) => !root.auto).length === 1, `starter must seed exactly the store root, got ${first.roots.length}`);
+    const storeEntry = first.roots.find((root) => root.config.store);
+    assert(storeEntry && storeEntry.config.store === true && storeEntry.config.name === "store", "starter store root wrong");
+    assert(!storeEntry!.config.enabled, "starter store root must start disabled");
+    assert(storeEntry!.issues.some((issue) => issue.includes("manifest")), "unscanned store root must carry an issue");
+
+    // Upsert a valid external root with a manifest, change a setting, save,
+    // reload — must round-trip.
+    const root: RootConfig = {
+        name: "roundtrip", enabled: false, transport: "skills-dir",
+        path: "/tmp/roundtrip", connection: "lazy",
+        skills: { mode: "selected", include: [] },
+    };
+    root.manifest = { version: 1, fingerprint: fingerprint(root), scannedAt: "t", skills: [snapshotStub()] };
+    first.settings.maxSkills = 37;
+    upsertRoot(first, root);
+    await saveManagerConfig(first, path);
+    const reloaded = await loadManagerConfig(path);
+    assert(!reloaded.created, "reload flagged as first run");
+    assert(reloaded.settings.maxSkills === 37, "settings did not round-trip");
+    const entry = reloaded.roots.find((item) => item.config.name === "roundtrip")!;
+    assert(entry && entry.normalized && !entry.issues.length, `root entry did not round-trip cleanly: ${entry?.issues.join("; ")}`);
+
+    // Remove, save, reload — entry gone, store root unaffected.
+    assert(removeRootEntry(reloaded, "roundtrip"), "removeRootEntry found nothing");
+    await saveManagerConfig(reloaded, path);
+    const afterRemove = await loadManagerConfig(path);
+    assert(!afterRemove.roots.some((item) => item.config.name === "roundtrip"), "removed entry came back");
+    assert(afterRemove.roots.some((item) => item.config.store), "store root lost across a save");
+
+    // Invalid settings fall back to defaults with issues; not fatal.
+    const settingsPath = join(dir, "settings.json");
+    await writeFile(settingsPath, JSON.stringify({ settings: { maxSkills: 999_999 }, registrar: [] }));
+    const withIssues = await loadManagerConfig(settingsPath);
+    assert(withIssues.settingsIssues.length > 0 && withIssues.settings.maxSkills === DEFAULT_SETTINGS.maxSkills, "invalid settings did not fall back");
+
+    // Unparseable file fails loudly.
+    const badPath = join(dir, "bad.json");
+    await writeFile(badPath, "{not json");
+    let threw = false;
+    try { await loadManagerConfig(badPath); } catch { threw = true; }
+    assert(threw, "unparseable config did not throw");
+
+    return { roundTrip: true, storeSeed: true, settingsFallback: true, loudFailure: true };
+}
+
+// ─── 5. Malformed-manifest safety ──────────────────────────────────────────
+
+async function malformedManifestSafety(): Promise<boolean> {
+    const dir = await tempDir("skill-smoke-bad-");
+    const path = join(dir, "malformed.json");
+    await writeFile(path, JSON.stringify({
+        version: 1,
+        registrar: [{
+            name: "bad", enabled: true, transport: "skills-dir", path: "/tmp/x",
+            skills: { mode: "all", include: [] },
+            manifest: { version: 1, fingerprint: "x", skills: "not-an-array" },
+        }],
+    }));
+    const loaded = await loadManagerConfig(path);
+    const root = loaded.roots[0]!;
+    assert(root.issues.length > 0, "malformed manifest produced no issues");
+    assert(manifestSkills(root.config).length === 0, "manifestSkills did not degrade safely");
+    assert(selectedSkills(root.config).length === 0, "selectedSkills did not degrade safely");
+    // The raw entry must survive a save round-trip (no silent destruction).
+    await saveManagerConfig(loaded, path);
+    const reloaded = await loadManagerConfig(path);
+    assert(reloaded.roots[0]!.issues.length > 0, "malformed entry lost its issues across a save");
+    return true;
+}
+
+// ─── 6. Executor suite (the production invocation path) ────────────────────
+
+async function executorSuite(settings: ManagerSettings): Promise<Record<string, unknown>> {
+    const dir = await tempDir("skill-smoke-exec-");
+
+    // Lazy proof A: building an executor never touches the disk.
+    const absentRoot: RootConfig = {
+        name: "absent", enabled: true, transport: "skills-dir",
+        path: join(dir, "does-not-exist"), connection: "lazy",
+        skills: { mode: "selected", include: [] },
+    };
+    const absentExecutor = buildManagedSkillExecutor(
+        absentRoot, snapshotStub(), settings,
+        createScanCache(settings).getScan, createScanCache(settings).evictScan,
+    );
+    assert(absentExecutor.name.startsWith("skill_absent__"), "executor tool name wrong");
+    // Lazy proof B: the failure happens at invocation (scan time), proving
+    // nothing was scanned at build time.
+    let lazyRejected = false;
+    try {
+        await absentExecutor.execute("t", {}, undefined, undefined, fakeCtx());
+    } catch (error) {
+        lazyRejected = String(error).includes("does not exist");
+    }
+    assert(lazyRejected, "invocation against a missing root did not fail with a readable scan error");
+
+    // Real invocation: copy the fixture store, approve one skill, call.
+    const store = join(dir, "store");
+    await cp(join(FIXTURES, "skills-dir"), store, { recursive: true });
+    const root: RootConfig = {
+        name: "store", enabled: true, transport: "skills-dir",
+        path: store, connection: "lazy",
+        skills: { mode: "selected", include: ["plain-skill"] },
+    };
+    const snapshot = await snapshotSkillFile(join(store, "plain", "SKILL.md"), "plain", settings);
+    const cache = createScanCache(settings);
+    const executor = buildManagedSkillExecutor(root, snapshot, settings, cache.getScan, cache.evictScan);
+    const result = await executor.execute("t1", {}, undefined, undefined, fakeCtx());
+    const text = JSON.stringify(result.content);
+    const callOk = text.includes("Skill directory:") && text.includes("Follow these instructions");
+    assert(callOk, "executor result did not carry the skill content");
+    assert((result.details as { skill: string }).skill === "plain-skill", "executor details wrong");
+    // Second call succeeds through the cached scan.
+    const again = await executor.execute("t2", {}, undefined, undefined, fakeCtx());
+    assert(JSON.stringify(again.content).includes("Follow these instructions"), "second invocation (scan reuse) failed");
+
+    // Drift: change the SKILL.md outside the manager — fail closed.
+    await writeFile(join(store, "plain", "SKILL.md"), "---\nname: plain-skill\ndescription: Tampered.\n---\nTampered body.\n");
+    let driftRejected = false;
+    try {
+        await executor.execute("t3", {}, undefined, undefined, fakeCtx());
+    } catch (error) {
+        driftRejected = String(error).includes("drift");
+    }
+    assert(driftRejected, "content drift was not rejected");
+    await cache.shutdown();
+    return { lazyRejected, callOk, reuseOk: true, driftRejected };
+}
+
+function fakeCtx(): import("@earendil-works/pi-coding-agent").ExtensionContext {
+    return { cwd: process.cwd(), ui: { notify: () => undefined } } as unknown as import("@earendil-works/pi-coding-agent").ExtensionContext;
+}
+
+// ─── 7. Name-length invariants ──────────────────────────────────────────────
+
+function nameInvariants(): boolean {
+    const pinned = piSkillToolName("a".repeat(48), "b".repeat(100), 64);
+    assert(pinned === "skill_aaaaaaaaaaaaaa_97daac__bbbbbbbbbbbbbbbbbbbbbbbbbb_d6cbb053", `pinned default-limit name changed: ${pinned}`);
+    for (const limit of [16, 17, 24, 31, 64, 100, 128]) {
+        for (const [root, skill] of [
+            ["a".repeat(48), "b".repeat(100)],
+            ["very-long-root-name", "some_skill_name"],
+            ["abc", "search_documents"],
+            ["s", "t"],
+        ] as const) {
+            const name = piSkillToolName(root, skill, limit);
+            assert(name.startsWith("skill_") && name.length <= limit, `piSkillToolName violated limit ${limit}: ${name} (len ${name.length})`);
+        }
+    }
+    return true;
+}
+
+// ─── 8. Scan budget / maxSkills enforcement ─────────────────────────────────
+
+async function cacheMaxSkillsHonored(): Promise<boolean> {
+    const settings: ManagerSettings = { ...DEFAULT_SETTINGS, maxSkills: 1 };
+    const root: RootConfig = {
+        name: "fixture", enabled: false, transport: "skills-dir",
+        path: join(FIXTURES, "skills-dir"), connection: "lazy",
+        skills: { mode: "selected", include: [] },
+    };
+    const cache = createScanCache(settings);
+    let caught = "";
+    try {
+        await cache.getScan(root, process.cwd());
+    } catch (error) {
+        caught = String(error);
+    } finally {
+        await cache.shutdown();
+    }
+    assert(caught.includes("more than 1"), `cache maxSkills failure wrong: ${caught}`);
+    return true;
+}
+
+// ─── 9. Native mirror computation ───────────────────────────────────────────
+
+async function nativeMirrorSuite(settings: ManagerSettings): Promise<boolean> {
+    const dir = await tempDir("skill-smoke-native-");
+    const store = join(dir, "native");
+    await cp(join(FIXTURES, "skills-dir"), store, { recursive: true });
+    const nativeRoot: RootConfig = {
+        name: "native-pi", enabled: true, native: true, transport: "skills-dir",
+        path: store, connection: "lazy",
+        skills: { mode: "selected", include: [] },   // nothing selected on purpose
+    };
+    const snapshot = await snapshotSkillFile(join(store, "plain", "SKILL.md"), "plain", settings);
+    nativeRoot.manifest = { version: 1, fingerprint: fingerprint(nativeRoot), scannedAt: "t", skills: [snapshot] };
+    // Mirror mode: pi is natively exposing the skill → exposed regardless of selection.
+    const live = new Set([skillFilePath(nativeRoot, snapshot, process.cwd())]);
+    const mirrored = computeExposedSkills(nativeRoot, process.cwd(), live);
+    assert(mirrored.length === 1 && mirrored[0]!.name === "plain-skill", "mirror exposure missing");
+    // Library-only mode (nothing natively active) → standard gate applies.
+    const gated = computeExposedSkills(nativeRoot, process.cwd(), new Set());
+    assert(gated.length === 0, "unselected skill exposed without native mirror");
+    // A disabled root never exposes, even mirrored.
+    const disabled = computeExposedSkills({ ...nativeRoot, enabled: false }, process.cwd(), live);
+    assert(disabled.length === 0, "disabled root exposed");
+    return true;
+}
+
+// ─── 10. Tree navigator construction ───────────────────────────────────────
+
+/** The tree the TUI renders: roots flat, groups nested, leaves carrying
+ *  the right kinds (normal / mirrored / unscanned / rejected), folds
+ *  hiding exactly their subtree. */
+async function treeSuite(settings: ManagerSettings): Promise<boolean> {
+    const dir = await tempDir("skill-smoke-tree-");
+    const store = join(dir, "store");
+    await cp(join(FIXTURES, "skills-dir"), store, { recursive: true });
+    const nativeStore = join(dir, "native");
+    await cp(join(FIXTURES, "single-skill"), nativeStore, { recursive: true });
+
+    const storeRoot: RootConfig = {
+        name: "store", store: true, enabled: true, transport: "skills-dir",
+        path: store, connection: "lazy", skills: { mode: "selected", include: ["plain-skill"] },
+    };
+    const plain = await snapshotSkillFile(join(store, "plain", "SKILL.md"), "plain", settings);
+    storeRoot.manifest = { version: 1, fingerprint: fingerprint(storeRoot), scannedAt: "t", skills: [plain] };
+
+    const nativeRoot: RootConfig = {
+        name: "native-pi", native: true, enabled: true, transport: "skills-dir",
+        path: nativeStore, connection: "lazy", skills: { mode: "selected", include: [] },
+    };
+    const solo = await snapshotSkillFile(join(nativeStore, "SKILL.md"), ".", settings);
+    nativeRoot.manifest = {
+        version: 1, fingerprint: fingerprint(nativeRoot), scannedAt: "t",
+        skills: [solo],
+        rejected: [{ dirPath: "ghosted", reason: "rejected by the strict scanner" }],
+    };
+
+    // A root whose ${...} path template cannot resolve (unset env var) must
+    // fail closed to zero exposure instead of crashing the tree builder.
+    const templateRoot: RootConfig = {
+        name: "template", enabled: true, transport: "skills-dir",
+        path: "${SSM_SMOKE_UNSET_VAR}/skills", connection: "lazy",
+        skills: { mode: "all", include: [] },
+    };
+    const templateSnap = await snapshotSkillFile(join(store, "plain", "SKILL.md"), "template-skill", settings);
+    templateRoot.manifest = { version: 1, fingerprint: fingerprint(templateRoot), scannedAt: "t", skills: [templateSnap] };
+
+    const config = await loadManagerConfig(join(dir, "unused-config.json"));
+    config.roots = [
+        { config: storeRoot, issues: [], normalized: true, raw: {} },
+        { config: nativeRoot, issues: [], normalized: true, raw: {} },
+        { config: templateRoot, issues: [], normalized: true, raw: {} },
+    ];
+
+    const ctx = {
+        cwd: process.cwd(),
+        getSystemPromptOptions: () => ({
+            skills: [{ filePath: join(nativeStore, "SKILL.md") }, { filePath: join(nativeStore, "unscanned/SKILL.md") }],
+        }),
+    } as unknown as import("@earendil-works/pi-coding-agent").ExtensionCommandContext;
+
+    // Must not throw despite the unresolvable template root.
+    const rows = buildTreeRows(config, ctx, nativeActivePathsFor(ctx));
+    // Roots sit flat at depth 0.
+    const roots = rows.filter((row) => row.type === "root");
+    assert(roots.length === 3 && roots.every((row) => row.depth === 0), "roots must sit flat");
+    // The template root fails closed: its live exposure is 0, while its
+    // skill's checkbox still reflects the configured mode:"all" selection
+    // (the checkbox edits config state; the label shows live exposure).
+    const templateRow = roots.find((row) => row.label.startsWith("template —"));
+    assert(templateRow?.label.includes("0/1 skills"), `template root must fail closed to 0 exposed: ${templateRow?.label}`);
+    const templateLeaf = rows.find((row) => row.type === "leaf" && row.leaf!.root.config.name === "template");
+    assert(templateLeaf?.leaf?.kind === "normal" && templateLeaf.leaf.checked === true, "template-root checkbox must reflect the configured selection");
+    // The store root has one group (ungrouped) with the exposed skill.
+    const plainLeaf = rows.find((row) => row.type === "leaf" && row.label === "plain-skill");
+    assert(plainLeaf?.leaf?.kind === "normal" && plainLeaf.leaf.checked === true, "plain-skill leaf wrong");
+    // The native root mirrors the live skill, flags the unscanned one, and
+    // lists the rejection — visibility, not gating.
+    const kinds = new Map(rows.filter((row) => row.type === "leaf").map((row) => [row.label, row.leaf!.kind]));
+    assert(kinds.get("solo-skill") === "mirror", `solo-skill must be a mirror, got ${kinds.get("solo-skill")}`);
+    assert(kinds.get("unscanned/SKILL.md") === "unscanned", "unscanned skill must be flagged");
+    assert(kinds.get("ghosted") === "rejected", "rejected skill must be listed");
+    const mirrorLeaf = rows.find((row) => row.leaf?.kind === "mirror")!.leaf!;
+    assert(mirrorLeaf.checked === true, "mirror leaves render as locked-exposed");
+    // Folds: folding the first root hides its groups and leaves, not others.
+    const folded = visibleRows(rows, new Set([roots[0]!.id]));
+    assert(folded.filter((row) => row.type === "leaf").every((row) => row.leaf!.root.config.name !== "store"), "fold must hide the root's subtree");
+    assert(folded.some((row) => row.leaf?.label === "solo-skill"), "fold must not hide other roots");
+    return true;
+}
+
+function nativeActivePathsFor(ctx: import("@earendil-works/pi-coding-agent").ExtensionCommandContext): Set<string> {
+    const skills = ctx.getSystemPromptOptions()?.skills ?? [];
+    return new Set(skills.map((skill) => skill.filePath ?? ""));
+}
+
+// ─── 11. Auto-adoption of native pi locations ───────────────────────────────
+
+/** A native pi directory that exists on disk appears in the registrar
+ *  automatically: disabled, unapproved, flagged auto — and never duplicated,
+ *  even after a save blesses it into the file. Runs LAST and cleans up after
+ *  itself (it creates the agent-dir native location for this process). */
+async function nativeAutoSuite(): Promise<boolean> {
+    const nativeDir = join(getAgentDir(), "skills");
+    const skillDir = join(nativeDir, "live-skill");
+    await mkdir(skillDir, { recursive: true });
+    try {
+        await writeFile(join(skillDir, "SKILL.md"),
+            "---\nname: live-skill\ndescription: A native skill found by auto-adoption.\n---\n\nLive.\n");
+        const dir = await tempDir("skill-smoke-auto-");
+        const path = join(dir, "config.json");
+        const loaded = await loadManagerConfig(path);
+        const auto = loaded.roots.find((root) => root.config.name === "pi-skills");
+        assert(auto && auto.auto === true, "auto-detected native root missing");
+        assert(auto!.config.native === true && auto!.config.enabled === false, "auto root must be a disabled native root");
+        assert(auto!.issues.some((issue) => issue.includes("Auto-detected")), "auto root must explain itself");
+        assert(!auto!.config.manifest, "auto root must not be pre-approved");
+        // Saving blesses the auto root into the file; a reload must not seed a duplicate.
+        await saveManagerConfig(loaded, path);
+        const reloaded = await loadManagerConfig(path);
+        const byPath = reloaded.roots.filter((root) => resolve(root.config.path) === resolve(nativeDir));
+        assert(byPath.length === 1, `auto root duplicated across a save: ${byPath.map((root) => root.config.name).join(", ")}`);
+        // Removing the directory removes the auto root again.
+        await rm(nativeDir, { recursive: true, force: true });
+        const withoutDir = await loadManagerConfig(join(dir, "config2.json"));
+        assert(!withoutDir.roots.some((root) => root.config.name === "pi-skills"), "auto root persisted after its directory vanished");
+    } finally {
+        await rm(nativeDir, { recursive: true, force: true }).catch(() => undefined);
+    }
+    return true;
+}
+
+// ─── Entry ─────────────────────────────────────────────────────────────────
+
+export default function smokeExtension(pi: ExtensionAPI): void {
+    pi.on("session_start", async () => {
+        const settings = { ...DEFAULT_SETTINGS };
+        try {
+            const scans = await scanSuite(settings);
+            const roundtrip = await configRoundTrip();
+            const executor = await executorSuite(settings);
+            const regressions = {
+                frontmatter: frontmatterSuite(),
+                validation: validationSuite(),
+                nameInvariants: nameInvariants(),
+                malformedManifestSafety: await malformedManifestSafety(),
+                cacheMaxSkillsHonored: await cacheMaxSkillsHonored(),
+                nativeMirror: await nativeMirrorSuite(settings),
+                treeBuilder: await treeSuite(settings),
+            };
+            const autoAdoption = await nativeAutoSuite();
+            await writeFile(RESULT, JSON.stringify({ ok: true, scans, roundtrip, executor, regressions, autoAdoption }));
+        } catch (error) {
+            await writeFile(RESULT, JSON.stringify({ ok: false, error: error instanceof Error ? error.message : String(error) }));
+        }
+    });
+}