@openpalm/lib 0.11.0-beta.11 → 0.11.0-beta.13

package/src/control-plane/registry.test.ts

@@ -20,6 +20,7 @@ import {
   getRegistryAutomation,
   getRegistryAddonConfig,
   listAvailableAddonIds,
+  listEnabledAddonIds,
   getAddonServiceNames,
   getAddonProfiles,
   getAddonProfileSelection,
@@ -31,6 +32,7 @@ import {
   annotateAddonProfileAvailability,
   __addonAvailabilityTestHooks,
 } from "./registry.js";
+import { readSecret } from './secrets-files.js';
 
 // ── Validation Tests ─────────────────────────────────────────────────
 
@@ -205,76 +207,76 @@ describe("materialized registry catalog", () => {
 
   it("materializes addons and automations into OP_HOME/registry", () => {
     const sourceRoot = join(tmpDir, 'repo');
-    const addonDir = join(sourceRoot, '.openpalm', 'state', 'registry', 'addons', 'chat');
-    const automationsDir = join(sourceRoot, '.openpalm', 'state', 'registry', 'automations');
+    const addonDir = join(sourceRoot, '.openpalm', 'data', 'registry', 'addons', 'chat');
+    const automationsDir = join(sourceRoot, '.openpalm', 'data', 'registry', 'automations');
 
     mkdirSync(addonDir, { recursive: true });
     mkdirSync(automationsDir, { recursive: true });
     writeFileSync(join(addonDir, 'compose.yml'), 'services: {}\n');
     writeFileSync(join(addonDir, '.env.schema'), 'CHANNEL_CHAT_SECRET=\n');
-    writeFileSync(join(automationsDir, 'cleanup.md'), '---\ndescription: Cleanup\nschedule: "0 3 * * *"\ncommand: ["echo","clean"]\n---\n');
+    writeFileSync(join(automationsDir, 'cleanup.yml'), 'description: Cleanup\nschedule: "0 3 * * *"\ncommand: ["echo","clean"]\n');
 
     const root = materializeRegistryCatalog(sourceRoot);
 
-    expect(root).toBe(join(process.env.OP_HOME!, 'state', 'registry'));
+    expect(root).toBe(join(process.env.OP_HOME!, 'data', 'registry'));
     expect(existsSync(join(root, 'addons', 'chat', 'compose.yml'))).toBe(true);
     expect(existsSync(join(root, 'addons', 'chat', '.env.schema'))).toBe(true);
-    expect(readFileSync(join(root, 'automations', 'cleanup.md'), 'utf-8')).toContain('Cleanup');
+    expect(readFileSync(join(root, 'automations', 'cleanup.yml'), 'utf-8')).toContain('Cleanup');
   });
 
   it("discovers materialized registry entries", () => {
     const sourceRoot = join(tmpDir, 'repo');
-    const addonDir = join(sourceRoot, '.openpalm', 'state', 'registry', 'addons', 'chat');
-    const automationsDir = join(sourceRoot, '.openpalm', 'state', 'registry', 'automations');
+    const addonDir = join(sourceRoot, '.openpalm', 'data', 'registry', 'addons', 'chat');
+    const automationsDir = join(sourceRoot, '.openpalm', 'data', 'registry', 'automations');
 
     mkdirSync(addonDir, { recursive: true });
     mkdirSync(automationsDir, { recursive: true });
     writeFileSync(join(addonDir, 'compose.yml'), 'services: {}\n');
     writeFileSync(join(addonDir, '.env.schema'), 'CHANNEL_CHAT_SECRET=\n');
-    writeFileSync(join(automationsDir, 'cleanup.md'), '---\ndescription: Cleanup\nschedule: "0 3 * * *"\ncommand: ["echo","clean"]\n---\n');
+    writeFileSync(join(automationsDir, 'cleanup.yml'), 'description: Cleanup\nschedule: "0 3 * * *"\ncommand: ["echo","clean"]\n');
 
     materializeRegistryCatalog(sourceRoot);
 
     const components = discoverRegistryComponents();
-    const stashDir = join(process.env.OP_HOME!, 'stash');
+    const stashDir = join(process.env.OP_HOME!, 'knowledge');
     const automations = discoverRegistryAutomations(stashDir);
 
     expect(Object.keys(components)).toEqual(['chat']);
     expect(components.chat?.schema).toContain('CHANNEL_CHAT_SECRET');
-    expect(automations.map((entry) => entry.name)).toEqual(['cleanup']);
-    expect(getRegistryAutomation('cleanup')).toContain('schedule: "0 3 * * *"');
+    expect(automations.map((entry) => entry.name)).toContain('akm-improve');
+    expect(getRegistryAutomation('akm-improve')).toContain('akm improve');
   });
 
   it("returns addon config metadata from the materialized registry", () => {
     const sourceRoot = join(tmpDir, 'repo');
-    const addonDir = join(sourceRoot, '.openpalm', 'state', 'registry', 'addons', 'chat');
-    const automationsDir = join(sourceRoot, '.openpalm', 'state', 'registry', 'automations');
+    const addonDir = join(sourceRoot, '.openpalm', 'data', 'registry', 'addons', 'chat');
+    const automationsDir = join(sourceRoot, '.openpalm', 'data', 'registry', 'automations');
 
     mkdirSync(addonDir, { recursive: true });
     mkdirSync(automationsDir, { recursive: true });
     writeFileSync(join(addonDir, 'compose.yml'), 'services: {}\n');
     writeFileSync(join(addonDir, '.env.schema'), 'CHANNEL_CHAT_SECRET=\n');
-    writeFileSync(join(automationsDir, 'cleanup.md'), '---\ndescription: Cleanup\nschedule: "0 3 * * *"\ncommand: ["echo","clean"]\n---\n');
+    writeFileSync(join(automationsDir, 'cleanup.yml'), 'description: Cleanup\nschedule: "0 3 * * *"\ncommand: ["echo","clean"]\n');
 
     materializeRegistryCatalog(sourceRoot);
 
     expect(getRegistryAddonConfig(process.env.OP_HOME!, 'chat')).toEqual({
-      schemaPath: 'state/registry/addons/chat/.env.schema',
-      userEnvPath: 'config/stack/stack.env',
-      envSchema: 'CHANNEL_CHAT_SECRET=\n',
+      schemaPath: '',
+      userEnvPath: 'knowledge/env/stack.env',
+      envSchema: '',
     });
   });
 
   it("verifies the materialized registry and returns counts", () => {
     const sourceRoot = join(tmpDir, 'repo');
-    const addonDir = join(sourceRoot, '.openpalm', 'state', 'registry', 'addons', 'chat');
-    const automationsDir = join(sourceRoot, '.openpalm', 'state', 'registry', 'automations');
+    const addonDir = join(sourceRoot, '.openpalm', 'data', 'registry', 'addons', 'chat');
+    const automationsDir = join(sourceRoot, '.openpalm', 'data', 'registry', 'automations');
 
     mkdirSync(addonDir, { recursive: true });
     mkdirSync(automationsDir, { recursive: true });
     writeFileSync(join(addonDir, 'compose.yml'), 'services: {}\n');
     writeFileSync(join(addonDir, '.env.schema'), 'CHANNEL_CHAT_SECRET=\n');
-    writeFileSync(join(automationsDir, 'cleanup.md'), '---\ndescription: Cleanup\nschedule: "0 3 * * *"\ncommand: ["echo","clean"]\n---\n');
+    writeFileSync(join(automationsDir, 'cleanup.yml'), 'description: Cleanup\nschedule: "0 3 * * *"\ncommand: ["echo","clean"]\n');
 
     const root = materializeRegistryCatalog(sourceRoot);
 
@@ -285,65 +287,58 @@ describe("materialized registry catalog", () => {
     });
   });
 
-  it("returns no available addons when the registry addons directory is missing", () => {
-    expect(listAvailableAddonIds()).toEqual([]);
+  it("returns static built-in addons without requiring a registry directory", () => {
+    expect(listAvailableAddonIds()).toEqual(['api', 'chat', 'discord', 'ollama', 'slack', 'ssh', 'voice']);
   });
 
   it("fails when source catalog is incomplete", () => {
     const sourceRoot = join(tmpDir, 'repo');
-    mkdirSync(join(sourceRoot, '.openpalm', 'state', 'registry', 'addons'), { recursive: true });
-    mkdirSync(join(sourceRoot, '.openpalm', 'state', 'registry', 'automations'), { recursive: true });
+    mkdirSync(join(sourceRoot, '.openpalm', 'data', 'registry', 'addons'), { recursive: true });
+    mkdirSync(join(sourceRoot, '.openpalm', 'data', 'registry', 'automations'), { recursive: true });
 
     expect(() => materializeRegistryCatalog(sourceRoot)).toThrow('Registry catalog is incomplete');
   });
 
-  it("enables and disables addons through the runtime stack directory", () => {
+  it("enables and disables addons through explicit runtime state", () => {
     const sourceRoot = join(tmpDir, 'repo');
-    const addonDir = join(sourceRoot, '.openpalm', 'state', 'registry', 'addons', 'chat');
-    const automationsDir = join(sourceRoot, '.openpalm', 'state', 'registry', 'automations');
+    const addonDir = join(sourceRoot, '.openpalm', 'data', 'registry', 'addons', 'chat');
+    const automationsDir = join(sourceRoot, '.openpalm', 'data', 'registry', 'automations');
 
     mkdirSync(addonDir, { recursive: true });
     mkdirSync(automationsDir, { recursive: true });
     writeFileSync(join(addonDir, 'compose.yml'), 'services: {}\n');
     writeFileSync(join(addonDir, '.env.schema'), 'CHANNEL_CHAT_SECRET=\n');
-    writeFileSync(join(automationsDir, 'cleanup.md'), '---\ndescription: Cleanup\nschedule: "0 3 * * *"\ncommand: ["echo","clean"]\n---\n');
+    writeFileSync(join(automationsDir, 'cleanup.yml'), 'description: Cleanup\nschedule: "0 3 * * *"\ncommand: ["echo","clean"]\n');
 
     materializeRegistryCatalog(sourceRoot);
 
     const stackDir = join(process.env.OP_HOME!, 'config', 'stack');
     expect(setAddonEnabled(process.env.OP_HOME!, stackDir, 'chat', true)).toMatchObject({ ok: true });
-    expect(existsSync(join(process.env.OP_HOME!, 'config', 'stack', 'addons', 'chat', 'compose.yml'))).toBe(true);
+    expect(listEnabledAddonIds(process.env.OP_HOME!)).toEqual(['chat']);
+    expect(existsSync(join(process.env.OP_HOME!, 'config', 'stack', 'addons', 'chat', 'compose.yml'))).toBe(false);
 
     expect(setAddonEnabled(process.env.OP_HOME!, stackDir, 'chat', false)).toMatchObject({ ok: true });
-    expect(existsSync(join(process.env.OP_HOME!, 'config', 'stack', 'addons', 'chat'))).toBe(false);
+    expect(listEnabledAddonIds(process.env.OP_HOME!)).toEqual([]);
   });
 
-  it("returns addon service names from stack or registry compose files", () => {
-    const sourceRoot = join(tmpDir, 'repo');
-    const addonDir = join(sourceRoot, '.openpalm', 'state', 'registry', 'addons', 'proxy-test');
-    const automationsDir = join(sourceRoot, '.openpalm', 'state', 'registry', 'automations');
-
-    mkdirSync(addonDir, { recursive: true });
-    mkdirSync(automationsDir, { recursive: true });
-    writeFileSync(join(addonDir, 'compose.yml'), 'services:\n  svc-a:\n    image: image-a\n  svc-b:\n    image: image-b\n');
-    writeFileSync(join(addonDir, '.env.schema'), 'PROXY_TOKEN=\n');
-    writeFileSync(join(automationsDir, 'cleanup.md'), '---\ndescription: Cleanup\nschedule: "0 3 * * *"\ncommand: ["echo","clean"]\n---\n');
-
-    materializeRegistryCatalog(sourceRoot);
+  it("returns addon service names from fixed compose files", () => {
+    const stackDir = join(process.env.OP_HOME!, 'config', 'stack');
+    mkdirSync(stackDir, { recursive: true });
+    writeFileSync(join(stackDir, 'custom.compose.yml'), 'services:\n  proxy-test:\n    profiles: ["addon.proxy-test"]\n    image: image-a\n  proxy-test-worker:\n    profiles: ["addon.proxy-test"]\n    image: image-b\n');
 
-    expect(getAddonServiceNames(process.env.OP_HOME!, 'proxy-test')).toEqual(['svc-a', 'svc-b']);
+    expect(getAddonServiceNames(process.env.OP_HOME!, 'proxy-test')).toEqual(['proxy-test', 'proxy-test-worker']);
   });
 
   it("toggles addons and generates channel secrets when enabling channel addons", () => {
     const sourceRoot = join(tmpDir, 'repo');
-    const addonDir = join(sourceRoot, '.openpalm', 'state', 'registry', 'addons', 'chat');
-    const automationsDir = join(sourceRoot, '.openpalm', 'state', 'registry', 'automations');
+    const addonDir = join(sourceRoot, '.openpalm', 'data', 'registry', 'addons', 'chat');
+    const automationsDir = join(sourceRoot, '.openpalm', 'data', 'registry', 'automations');
 
     mkdirSync(addonDir, { recursive: true });
     mkdirSync(automationsDir, { recursive: true });
     writeFileSync(join(addonDir, 'compose.yml'), 'services:\n  chat:\n    image: test\n    environment:\n      CHANNEL_NAME: "Chat"\n      CHANNEL_ID: "chat"\n');
     writeFileSync(join(addonDir, '.env.schema'), 'CHANNEL_CHAT_SECRET=\n');
-    writeFileSync(join(automationsDir, 'cleanup.md'), '---\ndescription: Cleanup\nschedule: "0 3 * * *"\ncommand: ["echo","clean"]\n---\n');
+    writeFileSync(join(automationsDir, 'cleanup.yml'), 'description: Cleanup\nschedule: "0 3 * * *"\ncommand: ["echo","clean"]\n');
 
     materializeRegistryCatalog(sourceRoot);
 
@@ -353,8 +348,8 @@ describe("materialized registry catalog", () => {
       changed: true,
       services: ['chat'],
     });
-    expect(existsSync(join(process.env.OP_HOME!, 'config', 'stack', 'addons', 'chat', 'compose.yml'))).toBe(true);
-    expect(readFileSync(join(process.env.OP_HOME!, 'config', 'stack', 'guardian.env'), 'utf-8')).toMatch(/CHANNEL_CHAT_SECRET=/);
+    expect(listEnabledAddonIds(process.env.OP_HOME!)).toEqual(['chat']);
+    expect(readSecret(join(process.env.OP_HOME!, 'config', 'stack'), 'channel_chat_secret')).toBeTruthy();
 
     expect(setAddonEnabled(process.env.OP_HOME!, join(process.env.OP_HOME!, 'config', 'stack'), 'chat', false)).toEqual({
       ok: true,
@@ -362,20 +357,21 @@ describe("materialized registry catalog", () => {
       changed: true,
       services: ['chat'],
     });
-    expect(existsSync(join(process.env.OP_HOME!, 'config', 'stack', 'addons', 'chat'))).toBe(false);
+    expect(listEnabledAddonIds(process.env.OP_HOME!)).toEqual([]);
   });
 
   it("backs up OP_HOME without recursively copying backups", () => {
     mkdirSync(join(process.env.OP_HOME!, 'config'), { recursive: true });
-    mkdirSync(join(process.env.OP_HOME!, 'backups', 'old-backup'), { recursive: true });
+    mkdirSync(join(process.env.OP_HOME!, 'data', 'backups', 'old-backup'), { recursive: true });
     writeFileSync(join(process.env.OP_HOME!, 'config', 'stack.yml'), 'llm: test\n');
-    writeFileSync(join(process.env.OP_HOME!, 'backups', 'old-backup', 'marker.txt'), 'old\n');
+    writeFileSync(join(process.env.OP_HOME!, 'data', 'backups', 'old-backup', 'marker.txt'), 'old\n');
 
     const backupDir = backupOpenPalmHome(process.env.OP_HOME!);
 
     expect(backupDir).not.toBeNull();
     expect(existsSync(join(backupDir!, 'config', 'stack.yml'))).toBe(true);
-    expect(existsSync(join(backupDir!, 'backups'))).toBe(false);
+    expect(existsSync(join(backupDir!, 'cache'))).toBe(false);
+    expect(existsSync(join(backupDir!, 'data', 'backups'))).toBe(false);
   });
 
   it("writes backups under the provided homeDir even when OP_HOME points elsewhere", () => {
@@ -383,7 +379,7 @@ describe("materialized registry catalog", () => {
     const otherHome = join(tmpDir, 'other-home');
 
     mkdirSync(join(actualHome, 'config'), { recursive: true });
-    mkdirSync(join(otherHome, 'backups'), { recursive: true });
+    mkdirSync(join(otherHome, 'data', 'backups'), { recursive: true });
     writeFileSync(join(actualHome, 'config', 'stack.yml'), 'llm: local\n');
 
     process.env.OP_HOME = otherHome;
@@ -391,15 +387,15 @@ describe("materialized registry catalog", () => {
     const backupDir = backupOpenPalmHome(actualHome);
 
     expect(backupDir).not.toBeNull();
-    expect(backupDir!.startsWith(join(actualHome, 'backups'))).toBe(true);
+    expect(backupDir!.startsWith(join(actualHome, 'data', 'backups'))).toBe(true);
     expect(existsSync(join(backupDir!, 'config', 'stack.yml'))).toBe(true);
-    expect(existsSync(join(otherHome, 'backups', 'config', 'stack.yml'))).toBe(false);
+    expect(existsSync(join(otherHome, 'data', 'backups', 'config', 'stack.yml'))).toBe(false);
   });
 
   it("parses compose profiles + openpalm.profile.* labels per addon", () => {
     const sourceRoot = join(tmpDir, 'repo');
-    const addonDir = join(sourceRoot, '.openpalm', 'state', 'registry', 'addons', 'voice');
-    const automationsDir = join(sourceRoot, '.openpalm', 'state', 'registry', 'automations');
+    const addonDir = join(sourceRoot, '.openpalm', 'data', 'registry', 'addons', 'voice');
+    const automationsDir = join(sourceRoot, '.openpalm', 'data', 'registry', 'automations');
 
     mkdirSync(addonDir, { recursive: true });
     mkdirSync(automationsDir, { recursive: true });
@@ -408,13 +404,13 @@ describe("materialized registry catalog", () => {
       [
         'services:',
         '  voice:',
-        '    profiles: [cpu]',
+        '    profiles: ["addon.voice.cpu"]',
         '    image: openpalm/voice:cpu',
         '    labels:',
         '      openpalm.profile.label: CPU',
         '      openpalm.profile.default: "true"',
         '  voice-cuda:',
-        '    profiles: [cuda]',
+        '    profiles: ["addon.voice.cuda"]',
         '    image: openpalm/voice:cuda',
         '    labels:',
         '      openpalm.profile.label: NVIDIA',
@@ -423,44 +419,57 @@ describe("materialized registry catalog", () => {
       ].join('\n'),
     );
     writeFileSync(join(addonDir, '.env.schema'), 'VOICE=\n');
-    writeFileSync(join(automationsDir, 'cleanup.md'), '---\ndescription: Cleanup\nschedule: "0 3 * * *"\ncommand: ["echo","clean"]\n---\n');
+    writeFileSync(join(automationsDir, 'cleanup.yml'), 'description: Cleanup\nschedule: "0 3 * * *"\ncommand: ["echo","clean"]\n');
 
     materializeRegistryCatalog(sourceRoot);
 
     const profiles = getAddonProfiles(process.env.OP_HOME!, 'voice');
     expect(profiles).toEqual([
-      { id: 'cpu', services: ['voice'], label: 'CPU', default: true },
-      { id: 'cuda', services: ['voice-cuda'], label: 'NVIDIA', requires: 'nvidia-container-toolkit' },
+      { id: 'addon.voice.cpu', services: ['voice'], label: 'CPU', default: true },
+      { id: 'addon.voice.cuda', services: ['voice-cuda'], label: 'NVIDIA (CUDA 12.1)', requires: 'nvidia-container-toolkit' },
+      { id: 'addon.voice.rocm', services: ['voice-rocm'], label: 'AMD (ROCm 6.x)', requires: 'amdgpu kernel module' },
     ]);
   });
 
   it("round-trips addon profile selection through stack.env", () => {
     const sourceRoot = join(tmpDir, 'repo');
-    const addonDir = join(sourceRoot, '.openpalm', 'state', 'registry', 'addons', 'voice');
-    const automationsDir = join(sourceRoot, '.openpalm', 'state', 'registry', 'automations');
+    const addonDir = join(sourceRoot, '.openpalm', 'data', 'registry', 'addons', 'voice');
+    const automationsDir = join(sourceRoot, '.openpalm', 'data', 'registry', 'automations');
 
     mkdirSync(addonDir, { recursive: true });
     mkdirSync(automationsDir, { recursive: true });
-    writeFileSync(join(addonDir, 'compose.yml'), 'services:\n  voice:\n    profiles: [cpu]\n    image: x\n');
+    writeFileSync(join(addonDir, 'compose.yml'), 'services:\n  voice:\n    profiles: ["addon.voice.cpu"]\n    image: x\n');
     writeFileSync(join(addonDir, '.env.schema'), 'VOICE=\n');
-    writeFileSync(join(automationsDir, 'cleanup.md'), '---\ndescription: Cleanup\nschedule: "0 3 * * *"\ncommand: ["echo","clean"]\n---\n');
+    writeFileSync(join(automationsDir, 'cleanup.yml'), 'description: Cleanup\nschedule: "0 3 * * *"\ncommand: ["echo","clean"]\n');
 
     materializeRegistryCatalog(sourceRoot);
 
     const stackDir = join(process.env.OP_HOME!, 'config', 'stack');
+    const stackEnv = join(process.env.OP_HOME!, 'knowledge', 'env', 'stack.env');
+    mkdirSync(stackDir, { recursive: true });
+    mkdirSync(join(process.env.OP_HOME!, 'knowledge', 'env'), { recursive: true });
+    writeFileSync(stackEnv, '');
+
+    expect(getAddonProfileSelection(stackDir, 'voice')).toBeNull();
+    setAddonProfileSelection(stackDir, 'voice', 'addon.voice.cuda');
+    expect(getAddonProfileSelection(stackDir, 'voice')).toBe('addon.voice.cuda');
+    expect(readFileSync(stackEnv, 'utf-8')).toContain('OP_VOICE_PROFILE=addon.voice.cuda');
+  });
+
+  it("ignores non-canonical addon profile values when reading stack.env", () => {
+    const stackDir = join(process.env.OP_HOME!, 'config', 'stack');
+    const stackEnv = join(process.env.OP_HOME!, 'knowledge', 'env', 'stack.env');
     mkdirSync(stackDir, { recursive: true });
-    writeFileSync(join(stackDir, 'stack.env'), '');
+    mkdirSync(join(process.env.OP_HOME!, 'knowledge', 'env'), { recursive: true });
+    writeFileSync(stackEnv, 'OP_VOICE_PROFILE=not-canonical\n');
 
     expect(getAddonProfileSelection(stackDir, 'voice')).toBeNull();
-    setAddonProfileSelection(stackDir, 'voice', 'cuda');
-    expect(getAddonProfileSelection(stackDir, 'voice')).toBe('cuda');
-    expect(readFileSync(join(stackDir, 'stack.env'), 'utf-8')).toContain('OP_VOICE_PROFILE=cuda');
   });
 
-  it("installs and uninstalls automations through stash/tasks", () => {
+  it("installs and uninstalls automations through knowledge/tasks", () => {
     const sourceRoot = join(tmpDir, 'repo');
-    const addonDir = join(sourceRoot, '.openpalm', 'state', 'registry', 'addons', 'chat');
-    const automationsDir = join(sourceRoot, '.openpalm', 'state', 'registry', 'automations');
+    const addonDir = join(sourceRoot, '.openpalm', 'data', 'registry', 'addons', 'chat');
+    const automationsDir = join(sourceRoot, '.openpalm', 'data', 'registry', 'automations');
     const configDir = join(process.env.OP_HOME!, 'config');
 
     mkdirSync(addonDir, { recursive: true });
@@ -468,16 +477,16 @@ describe("materialized registry catalog", () => {
     mkdirSync(configDir, { recursive: true });
     writeFileSync(join(addonDir, 'compose.yml'), 'services: {}\n');
     writeFileSync(join(addonDir, '.env.schema'), 'CHANNEL_CHAT_SECRET=\n');
-    writeFileSync(join(automationsDir, 'cleanup.md'), '---\ndescription: Cleanup\nschedule: "0 3 * * *"\ncommand: ["echo","clean"]\n---\n');
+    writeFileSync(join(automationsDir, 'cleanup.yml'), 'description: Cleanup\nschedule: "0 3 * * *"\ncommand: ["echo","clean"]\n');
 
     materializeRegistryCatalog(sourceRoot);
 
-    const stashDir = join(process.env.OP_HOME!, 'stash');
+    const stashDir = join(process.env.OP_HOME!, 'knowledge');
     expect(installAutomationFromRegistry('cleanup', stashDir)).toEqual({ ok: true });
-    expect(readFileSync(join(stashDir, 'tasks', 'cleanup.md'), 'utf-8')).toContain('Cleanup');
+    expect(readFileSync(join(stashDir, 'tasks', 'cleanup.yml'), 'utf-8')).toContain('Cleanup');
 
     expect(uninstallAutomation('cleanup', stashDir)).toEqual({ ok: true });
-    expect(existsSync(join(stashDir, 'tasks', 'cleanup.md'))).toBe(false);
+    expect(existsSync(join(stashDir, 'tasks', 'cleanup.yml'))).toBe(false);
   });
 });
 
@@ -493,7 +502,7 @@ describe("getAddonProfileAvailability", () => {
   });
 
   it("returns available:true for the cpu profile (no host requirements)", async () => {
-    const result = await getAddonProfileAvailability({ id: 'cpu' });
+    const result = await getAddonProfileAvailability({ id: 'addon.voice.cpu' });
     expect(result.available).toBe(true);
     expect(result.reason).toBeUndefined();
   });
@@ -504,8 +513,8 @@ describe("getAddonProfileAvailability", () => {
   });
 
   it("caches the result across calls (probe runs only once)", async () => {
-    const a = await getAddonProfileAvailability({ id: 'cpu' });
-    const b = await getAddonProfileAvailability({ id: 'cpu' });
+    const a = await getAddonProfileAvailability({ id: 'addon.voice.cpu' });
+    const b = await getAddonProfileAvailability({ id: 'addon.voice.cpu' });
     expect(a).toBe(b); // same reference — cached
   });
 
@@ -514,7 +523,7 @@ describe("getAddonProfileAvailability", () => {
     // we just assert the contract: when neither signal is present, the
     // reason mentions nvidia-container-toolkit. If a future GPU host runs
     // this test, the assertion still tolerates the success case.
-    const result = await getAddonProfileAvailability({ id: 'cuda' });
+    const result = await getAddonProfileAvailability({ id: 'addon.voice.cuda' });
     if (!result.available) {
       expect(result.reason).toContain('NVIDIA');
     } else {
@@ -524,7 +533,7 @@ describe("getAddonProfileAvailability", () => {
   });
 
   it("probes rocm: returns available:false when /dev/kfd is missing", async () => {
-    const result = await getAddonProfileAvailability({ id: 'rocm' });
+    const result = await getAddonProfileAvailability({ id: 'addon.voice.rocm' });
     if (!result.available) {
       expect(result.reason).toContain('ROCm');
     } else {
@@ -538,7 +547,7 @@ describe("getAddonProfileAvailability", () => {
     // through to the manifest-inspect probe and (until 0.11.0-rocm6
     // ships) get the "image not published yet" copy. Both must mention
     // ROCm so operator-facing copy stays consistent.
-    const result = await getAddonProfileAvailability({ id: 'rocm' });
+    const result = await getAddonProfileAvailability({ id: 'addon.voice.rocm' });
     if (!result.available && existsSync('/dev/kfd') && existsSync('/dev/dri')) {
       expect(result.reason).toMatch(/image not published|CPU profile/i);
     }
@@ -588,21 +597,21 @@ describe("annotateAddonProfileAvailability", () => {
 
   it("decorates each profile with available + optional reason", async () => {
     const out = await annotateAddonProfileAvailability([
-      { id: 'cpu', services: ['voice'], label: 'CPU', default: true },
-      { id: 'rocm', services: ['voice-rocm'], label: 'AMD' },
+      { id: 'addon.voice.cpu', services: ['voice'], label: 'CPU', default: true },
+      { id: 'addon.voice.rocm', services: ['voice-rocm'], label: 'AMD' },
     ]);
     expect(out).toHaveLength(2);
-    expect(out[0]?.id).toBe('cpu');
+    expect(out[0]?.id).toBe('addon.voice.cpu');
     expect(out[0]?.available).toBe(true);
     // Preserves original fields.
     expect(out[0]?.label).toBe('CPU');
     expect(out[0]?.default).toBe(true);
-    expect(out[1]?.id).toBe('rocm');
+    expect(out[1]?.id).toBe('addon.voice.rocm');
     expect(typeof out[1]?.available).toBe('boolean');
   });
 
   it("does not mutate the input array", async () => {
-    const input = [{ id: 'cpu', services: ['voice'] }];
+    const input = [{ id: 'addon.voice.cpu', services: ['voice'] }];
     const before = JSON.parse(JSON.stringify(input));
     await annotateAddonProfileAvailability(input);
     expect(input).toEqual(before);