@inneranimalmedia/agentsam-sdk 2.6.3 → 2.6.5

package/test/integration/cms-app-scaffold.test.mjs

@@ -0,0 +1,71 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+import { execFileSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
+const cmsBin = path.join(root, 'apps/client-cms-editor/bin/agentsam-cms.mjs');
+
+function scaffold(persistence) {
+  const temp = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-cms-scaffold-'));
+  const target = path.join(temp, 'editor');
+  execFileSync(process.execPath, [
+    cmsBin,
+    'scaffold',
+    target,
+    '--persistence',
+    persistence,
+  ], { cwd: root, stdio: 'pipe' });
+  return { temp, target };
+}
+
+test('CMS editor scaffold is self-contained and records SQLite authority', () => {
+  const { temp, target } = scaffold('sqlite');
+  try {
+    assert.equal(fs.existsSync(path.join(target, 'bin/agentsam-cms.mjs')), true);
+    assert.equal(fs.existsSync(path.join(target, 'agentsam.app.json')), true);
+    assert.equal(fs.existsSync(path.join(target, 'packages/agentsam-contracts/package.json')), true);
+    assert.equal(fs.existsSync(path.join(target, 'packages/agentsam-workbench/package.json')), true);
+
+    const rootPkg = JSON.parse(fs.readFileSync(path.join(target, 'package.json'), 'utf8'));
+    assert.ok(rootPkg.workspaces.includes('packages/*'));
+
+    const frontendPkg = JSON.parse(fs.readFileSync(path.join(target, 'frontend/package.json'), 'utf8'));
+    assert.equal(frontendPkg.dependencies['@inneranimalmedia/agentsam-contracts'], '0.1.0');
+    assert.equal(frontendPkg.dependencies['@inneranimalmedia/agentsam-workbench'], '0.1.0');
+
+    const sharedPkg = JSON.parse(fs.readFileSync(path.join(target, 'shared/cms/package.json'), 'utf8'));
+    assert.equal(sharedPkg.dependencies['@inneranimalmedia/agentsam-contracts'], '0.1.0');
+
+    const escaped = [
+      ...Object.values(frontendPkg.dependencies || {}),
+      ...Object.values(sharedPkg.dependencies || {}),
+    ].filter((value) => String(value).startsWith('file:'));
+    assert.deepEqual(escaped, []);
+
+    const runtime = JSON.parse(fs.readFileSync(path.join(target, '.agentsam/cms-runtime.json'), 'utf8'));
+    assert.equal(runtime.schema, 'agentsam.cms.runtime.v1');
+    assert.equal(runtime.app_id, 'client-cms-editor');
+    assert.equal(runtime.authority, 'sqlite');
+    assert.equal(runtime.cache, 'localStorage');
+    assert.equal(runtime.cache_only, false);
+  } finally {
+    fs.rmSync(temp, { recursive: true, force: true });
+  }
+});
+
+test('CMS editor localStorage option is explicitly cache-only', () => {
+  const { temp, target } = scaffold('localStorage');
+  try {
+    const runtime = JSON.parse(fs.readFileSync(path.join(target, '.agentsam/cms-runtime.json'), 'utf8'));
+    assert.equal(runtime.authority, null);
+    assert.equal(runtime.cache, 'localStorage');
+    assert.equal(runtime.cache_only, true);
+    assert.match(runtime.note, /cache only/i);
+  } finally {
+    fs.rmSync(temp, { recursive: true, force: true });
+  }
+});

package/test/integration/cms-site-tenancy-contract.test.mjs

@@ -124,8 +124,9 @@ test('Local Studio Worker dispatches /api/cms/* with strict tenant isolation', (
   assert.match(workerContent, /handleCmsWorkerRequest/);
 
   const cmsService = read('apps', 'local-studio', 'backend', 'worker', 'cms-service.js');
-  // Default fallback must be agentsam-sdk, never inneranimalmedia
-  assert.match(cmsService, /'agentsam-sdk'/);
+  // Worker requests must name their tenant explicitly; the UI may choose its own default.
+  assert.match(cmsService, /site_slug_required/);
+  assert.doesNotMatch(cmsService, /['"]agentsam-sdk['"]/);
   assert.match(cmsService, /createCmsDbClient\(env\.DB,\s*siteSlug\)/);
 });
 
@@ -143,13 +144,13 @@ test('homepage.html is decomposed into reusable site partials with relative link
   assert.ok(header.length > 500, 'header.html must contain full header content');
   assert.ok(footer.length > 500, 'footer.html must contain full footer content');
 
-  // Relative navigation links (R2 partial SSOT)
-  assert.match(header, /href="\/work"/);
-  assert.match(header, /href="\/about"/);
-  assert.match(header, /href="\/services"/);
-  assert.match(header, /href="\/contact"/);
+  // AgentSam public header navigation is relative and product-specific (R2 partial SSOT).
+  assert.match(header, /href="\/"/);
+  assert.match(header, /href="\/learn\/"/);
+  assert.match(header, /href="\/themes\/"/);
+  assert.match(header, /href="\/packages\/sdk\/help\/"/);
   assert.match(header, /href="\/auth\/login\?next=\/agentsam"/);
-  assert.doesNotMatch(header, /href="https:\/\/inneranimalmedia\.com\/(work|about|services|contact)"/);
+  assert.doesNotMatch(header, /href="https:\/\/inneranimalmedia\.com\/(learn|themes|packages\/sdk|agentsam)"/);
 
   assert.match(footer, /href="\/work"/);
   assert.match(footer, /href="\/about"/);

package/test/integration/codebaseindex-ingest.test.mjs

@@ -0,0 +1,214 @@
+import assert from 'node:assert/strict';
+import { describe, it, before } from 'node:test';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+import {
+  getCliCommand,
+  listCliCommands,
+  printAssistTip,
+  suggestCliCommands,
+} from '../../src/cli/command-catalog.js';
+import { parsePastedPaths, classifyMaterial, stageMaterials } from '../../src/indexing/ingest/materials.js';
+import { ensureSeedOperations, getSamOperation, AgentSamClient } from '../../src/sam/index.js';
+import { getSkill, loadSkill } from '../../src/skills/index.js';
+import { resolveHelpTopic, renderHelpOverview } from '../../src/ui/cli/help.js';
+import { runCodebaseindexIngest } from '../../src/commands/codebaseindex.js';
+import { buildInventory } from '../../src/indexing/ingest/inventory.js';
+
+describe('CLI command catalog assist', () => {
+  it('maps ingest alias to codebaseindex with skill tip', () => {
+    const entry = getCliCommand('ingest');
+    assert.equal(entry?.id, 'codebaseindex');
+    assert.equal(entry?.skill, 'agentsam-codebaseindex');
+    assert.equal(entry?.operation, 'codebaseindex.ingest');
+  });
+
+  it('prints tip: use skill for every catalogued command', () => {
+    const chunks = [];
+    for (const entry of listCliCommands()) {
+      if (!entry.skill) continue;
+      printAssistTip(entry, { write: (s) => chunks.push(s) });
+    }
+    const text = chunks.join('');
+    assert.match(text, /tip: use skill agentsam-codebaseindex/);
+    assert.match(text, /tip: use skill agentsam-app-fundamentals/);
+  });
+
+  it('suggests commands for typos', () => {
+    const hits = suggestCliCommands('codebase');
+    assert.ok(hits.some((h) => h.id === 'codebaseindex'));
+  });
+});
+
+describe('material paste/drop intake', () => {
+  it('parses pasted multi-path text', () => {
+    const paths = parsePastedPaths('/tmp/a.tar.gz\n"./site build"/index.html  screenshot.png');
+    assert.ok(paths.includes('/tmp/a.tar.gz'));
+    assert.ok(paths.some((p) => p.includes('index.html') || p.endsWith('screenshot.png')));
+  });
+
+  it('stages html and classifies archives', () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-ingest-'));
+    const html = path.join(root, 'page.html');
+    fs.writeFileSync(html, '<html><body>hi</body></html>');
+    const classified = classifyMaterial(html);
+    assert.equal(classified.kind, 'document');
+
+    const tarPath = path.join(root, 'site.tar');
+    const bundle = path.join(root, 'bundle');
+    fs.mkdirSync(bundle);
+    fs.writeFileSync(path.join(bundle, 'index.html'), '<html>build</html>');
+    execFileSync('tar', ['-cf', tarPath, '-C', bundle, '.']);
+
+    const staged = stageMaterials({ root, materials: [html, tarPath] });
+    assert.equal(staged.schema, 'agentsam.ingest.materials.v1');
+    assert.ok(staged.include.length >= 1);
+    assert.ok(staged.assets.some((a) => a.kind === 'document') || staged.items.some((i) => i.kind === 'archive'));
+    assert.ok(fs.existsSync(path.join(root, staged.stage_root, 'manifest.json')));
+  });
+});
+
+describe('codebaseindex SAM primitive', () => {
+  before(() => ensureSeedOperations());
+
+  it('registers codebaseindex.ingest', () => {
+    const op = getSamOperation('codebaseindex.ingest');
+    assert.ok(op);
+    assert.equal(op.execution.model, 'optional');
+    assert.deepEqual(op.cli.command[0], ['codebaseindex']);
+  });
+
+  it('skill agentsam-codebaseindex loads', () => {
+    assert.ok(getSkill('ingest'));
+    const loaded = loadSkill('agentsam-codebaseindex');
+    assert.match(loaded.instructions, /codebaseindex\.ingest/);
+    assert.match(loaded.instructions, /sam\.codebaseindex\.index\.run/);
+  });
+
+  it('describe + discover surface ingest', async () => {
+    const sam = new AgentSamClient();
+    const info = await sam.describe('codebaseindex.ingest');
+    assert.equal(info.ok, true);
+    const found = await sam.discover({ query: 'ingest archive embedding' });
+    assert.ok(found.operations.some((c) => c.id === 'codebaseindex.ingest'));
+  });
+
+  it('plan-only ingest via invoke (repo allowlist)', async () => {
+    const sam = new AgentSamClient();
+    const result = await sam.invoke('codebaseindex.ingest', {
+      root: process.cwd(),
+      include: ['src/sam'],
+      exclude: ['node_modules', '.git'],
+      embeddingChoice: 'none',
+      planOnly: true,
+    });
+    assert.equal(result.ok, true);
+    assert.equal(result.data?.pipeline, 'sam.codebaseindex.index.run');
+    assert.equal(result.data?.mode, 'plan');
+  });
+});
+
+describe('codebaseindex real execution', () => {
+  it('publishes, smoke-searches, completes the graph, and returns portable paths', async () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-codebaseindex-run-'));
+    fs.mkdirSync(path.join(root, 'src'), { recursive: true });
+    fs.writeFileSync(
+      path.join(root, 'src', 'demo.js'),
+      'export function hello() { return "hello AgentSam"; }\n',
+    );
+
+    const result = await runCodebaseindexIngest({
+      root,
+      include: ['src'],
+      exclude: [],
+      embeddingChoice: 'none',
+      embed: false,
+      planOnly: false,
+    });
+
+    assert.equal(result.mode, 'run');
+    assert.equal(result.root, '.');
+    assert.equal(result.inventory.root, '.');
+
+    assert.equal(result.index.published, true);
+    assert.equal(result.job_graph.status, 'completed');
+    assert.equal(result.job_graph.current, null);
+    assert.equal(
+      result.job_graph.nodes.find((node) => node.id === 'embedding.generate')?.status,
+      'skipped',
+    );
+    assert.equal(
+      result.job_graph.nodes.find((node) => node.id === 'search.smoke')?.status,
+      'done',
+    );
+
+    assert.equal(
+      result.search_smoke.generation_id,
+      result.index.generation_id,
+    );
+    assert.ok(result.search_smoke.sources_included >= 1);
+  });
+});
+
+describe('catalog-driven help', () => {
+  it('resolves ingest topic from catalog', () => {
+    const topic = resolveHelpTopic('ingest');
+    assert.ok(topic);
+    assert.ok(topic.rows.some(([cmd]) => cmd.includes('codebaseindex')));
+  });
+
+  it('overview mentions skill baseline', () => {
+    const text = renderHelpOverview('2.6.3');
+    assert.match(text, /tip: use skill/);
+    assert.match(text, /command catalog/i);
+  });
+});
+
+describe('Cargo workspace inventory', () => {
+  it('treats workspace members as source and keeps generated/operational state out of the starting scope', () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-cargo-workspace-'));
+    try {
+      fs.writeFileSync(path.join(root, 'Cargo.toml'), `[workspace]
+members = [
+  "core",
+  "worker",
+]
+resolver = "2"
+`);
+      for (const crate of ['core', 'worker']) {
+        fs.mkdirSync(path.join(root, crate, 'src'), { recursive: true });
+        fs.writeFileSync(path.join(root, crate, 'Cargo.toml'), `[package]
+name = "${crate}"
+version = "0.1.0"
+edition = "2024"
+`);
+        fs.writeFileSync(path.join(root, crate, 'src', 'lib.rs'), `pub fn ${crate}_value() -> u32 { 1 }
+`);
+      }
+      fs.mkdirSync(path.join(root, 'docs'), { recursive: true });
+      fs.writeFileSync(path.join(root, 'docs', 'README.md'), '# docs\n');
+      fs.mkdirSync(path.join(root, 'target'), { recursive: true });
+      fs.writeFileSync(path.join(root, 'target', 'build.txt'), 'generated\n');
+      fs.mkdirSync(path.join(root, '.agentsam', 'machine'), { recursive: true });
+      fs.writeFileSync(path.join(root, '.agentsam', 'machine', 'state.sqlite'), '');
+
+      const inventory = buildInventory({ root });
+      assert.deepEqual(inventory.cargo_workspace_roots, ['core', 'worker']);
+      assert.ok(inventory.categories.source.includes('core'));
+      assert.ok(inventory.categories.source.includes('worker'));
+      assert.ok(inventory.categories.docs.includes('docs'));
+      assert.ok(inventory.categories.dependencies.includes('target'));
+      assert.ok(inventory.categories.operational.includes('.agentsam'));
+
+      assert.ok(inventory.suggested.include.includes('core'));
+      assert.ok(inventory.suggested.include.includes('worker'));
+      assert.ok(inventory.suggested.include.includes('docs'));
+      assert.ok(inventory.suggested.exclude.includes('target'));
+      assert.ok(inventory.suggested.exclude.includes('.agentsam'));
+    } finally {
+      fs.rmSync(root, { recursive: true, force: true });
+    }
+  });
+});

package/test/integration/features-resolve.test.mjs

@@ -44,9 +44,11 @@ test('auth feature resolves real D1 resources, not a pretend iam-d1 profile', ()
   assert.deepEqual(resolved.resources.migration_sources, [
     'src/migrations/0001_identity_core.sql',
     'src/migrations/0002_company.sql',
+    'src/migrations/0003_accounts_ssot.sql',
   ]);
   const names = resolved.resources.tables.map((t) => t.name);
   assert.deepEqual(names, [
+    'accounts',
     'auth_users',
     'auth_sessions',
     'account_identities',
@@ -54,7 +56,7 @@ test('auth feature resolves real D1 resources, not a pretend iam-d1 profile', ()
     'password_reset_tokens',
     'company',
   ]);
-  assert.match(formatResourcesSummary(resolved.resources), /tables=auth_users,/);
+  assert.match(formatResourcesSummary(resolved.resources), /tables=accounts,auth_users,/);
   assert.doesNotMatch(formatResourcesSummary(resolved.resources), /iam-d1/);
 });
 
@@ -82,6 +84,7 @@ test('resources.json indexes D1 tables without owning DDL', () => {
   assert.deepEqual(resources.migration_sources, [
     'src/migrations/0001_identity_core.sql',
     'src/migrations/0002_company.sql',
+    'src/migrations/0003_accounts_ssot.sql',
   ]);
   const names = resources.tables.map((t) => t.name);
   assert.ok(names.includes('auth_users'));
@@ -115,14 +118,30 @@ test('writeFeatureSelections emits schema_version 2 and resolved snapshot', () =
   }
 });
 
-test('sdk project selections resolve against package packet', () => {
-  const { snapshot } = writeFeaturesResolved(SDK_ROOT);
-  assert.equal(snapshot.schema, 'agentsam.features.resolved.v1');
-  assert.equal(snapshot.features.auth.provider_template, 'inneranimalmedia');
-  assert.equal(snapshot.features.auth.feature.id, 'identity.oauth-login-portal');
-  assert.equal(snapshot.features.auth.resources.engine, 'd1');
-  assert.match(
-    formatResourcesSummary(snapshot.features.auth.resources),
-    /auth_users,auth_sessions,account_identities/,
-  );
+test('sdk-style project selections resolve against package packet without local machine state', () => {
+  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-sdk-feature-select-'));
+  try {
+    const { snapshot } = writeFeaturesResolved(cwd, null, {
+      selections: {
+        schema_version: 2,
+        features: {
+          auth: {
+            selected: true,
+            capabilities: ['identity.init'],
+            provider_template: 'inneranimalmedia',
+          },
+        },
+      },
+    });
+    assert.equal(snapshot.schema, 'agentsam.features.resolved.v1');
+    assert.equal(snapshot.features.auth.provider_template, 'inneranimalmedia');
+    assert.equal(snapshot.features.auth.feature.id, 'identity.oauth-login-portal');
+    assert.equal(snapshot.features.auth.resources.engine, 'd1');
+    assert.match(
+      formatResourcesSummary(snapshot.features.auth.resources),
+      /auth_users,auth_sessions,account_identities/,
+    );
+  } finally {
+    fs.rmSync(cwd, { recursive: true, force: true });
+  }
 });

package/test/integration/icon-registry.test.mjs

@@ -0,0 +1,67 @@
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import {
+  AGENTSAM_ICON_KEYS,
+  normalizeIconKey,
+  isAgentsamIconKey,
+  resolveCliIconGlyph,
+  createIconRenderer,
+  ICON_ALIASES,
+} from '../../protocol/ui/icon-registry.mjs';
+import iconSchema from '../../protocol/ui/icon.v1.schema.json' with { type: 'json' };
+
+describe('agentsam.icon.v1', () => {
+  it('schema enum matches registry keys', () => {
+    assert.deepEqual([...(iconSchema.enum || [])].sort(), [...AGENTSAM_ICON_KEYS].sort());
+  });
+
+  it('includes generic fallback and first-class AgentSam concepts', () => {
+    for (const key of [
+      'generic',
+      'database',
+      'vector',
+      'identity',
+      'key',
+      'brand',
+      'theme',
+      'app',
+      'repository',
+      'connection',
+      'metrics',
+    ]) {
+      assert.equal(isAgentsamIconKey(key), true, key);
+    }
+  });
+
+  it('normalizes aliases and rejects lucide/emoji-like values to generic', () => {
+    assert.equal(normalizeIconKey('db'), 'database');
+    assert.equal(normalizeIconKey('repo'), 'repository');
+    assert.equal(normalizeIconKey('lucide-database'), 'database');
+    assert.equal(normalizeIconKey('🗄️'), 'generic');
+    assert.equal(normalizeIconKey(''), 'generic');
+    assert.equal(normalizeIconKey('unknown-future-key'), 'generic');
+  });
+
+  it('createIconRenderer falls back to generic without throwing', () => {
+    const render = createIconRenderer(
+      { database: 'DB', generic: 'G', identity: 'ID' },
+      'FALLBACK',
+    );
+    assert.equal(render('database'), 'DB');
+    assert.equal(render('db'), 'DB');
+    assert.equal(render('not-a-real-icon'), 'G');
+    assert.equal(render('identity'), 'ID');
+  });
+
+  it('CLI glyphs always resolve', () => {
+    assert.ok(resolveCliIconGlyph('database'));
+    assert.equal(resolveCliIconGlyph('totally-unknown'), resolveCliIconGlyph('generic'));
+  });
+
+  it('aliases only map to canonical vocabulary', () => {
+    for (const [from, to] of Object.entries(ICON_ALIASES)) {
+      assert.equal(isAgentsamIconKey(to), true, `${from} → ${to}`);
+      assert.equal(normalizeIconKey(from), to);
+    }
+  });
+});

package/test/integration/ingest-discover-models.test.mjs

@@ -0,0 +1,30 @@
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import {
+  encodeEmbeddingChoice,
+  parseEmbeddingChoice,
+  looksLikeEmbedModel,
+} from '../../src/indexing/ingest/discover-models.js';
+
+describe('ingest model discovery helpers', () => {
+  it('encodes/decodes embedding choices without breaking model ids that contain colons', () => {
+    const value = encodeEmbeddingChoice('ollama', 'mxbai-embed-large:latest', 1024);
+    assert.equal(value, 'ollama|mxbai-embed-large:latest|1024');
+    const parsed = parseEmbeddingChoice(value);
+    assert.equal(parsed.provider, 'ollama');
+    assert.equal(parsed.model, 'mxbai-embed-large:latest');
+    assert.equal(parsed.dimensions, 1024);
+  });
+
+  it('treats none as disabled embedding', () => {
+    const parsed = parseEmbeddingChoice('none');
+    assert.equal(parsed.provider, 'none');
+    assert.equal(parsed.dimensions, 0);
+  });
+
+  it('classifies ollama embed vs chat tags', () => {
+    assert.equal(looksLikeEmbedModel('mxbai-embed-large:latest'), true);
+    assert.equal(looksLikeEmbedModel('nomic-embed-text'), true);
+    assert.equal(looksLikeEmbedModel('qwen2.5-coder:latest'), false);
+  });
+});

package/test/integration/inspect-path-cli.test.mjs

@@ -0,0 +1,46 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
+const CLI = path.join(ROOT, 'bin/agentsam');
+
+function run(args, cwd = ROOT) {
+  return spawnSync(process.execPath, [CLI, ...args], {
+    cwd,
+    encoding: 'utf8',
+    env: { ...process.env, NO_COLOR: '1' },
+  });
+}
+
+function jsonFrom(text) {
+  const start = text.indexOf('{');
+  assert.notEqual(start, -1, `expected JSON output, received: ${text}`);
+  return JSON.parse(text.slice(start));
+}
+
+test('agentsam inspect --help documents the positional path world-state contract', () => {
+  const result = run(['inspect', '--help']);
+  assert.equal(result.status, 0, result.stderr);
+  assert.match(result.stdout, /agentsam inspect \[path\]/);
+  assert.match(result.stdout, /deterministic repository world state/i);
+  assert.match(result.stdout, /No model, embeddings, network, provider spend/i);
+});
+
+test('agentsam inspect accepts a repository path as the first positional argument', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-inspect-path-'));
+  fs.writeFileSync(path.join(root, 'package.json'), JSON.stringify({ name: 'inspect-fixture', version: '1.0.0' }));
+  fs.mkdirSync(path.join(root, 'src'));
+  fs.writeFileSync(path.join(root, 'src/index.js'), 'export function fixture() { return 42; }\n');
+
+  const result = run(['inspect', root, '--json', '--index']);
+  assert.equal(result.status, 0, result.stderr || result.stdout);
+  const output = jsonFrom(result.stdout);
+  assert.ok(output.snapshot_id);
+  assert.ok(output.merkle_root || output.tree?.merkle_root);
+  assert.match(JSON.stringify(output), /inspect-fixture|src\/index\.js/);
+});

package/test/integration/install-script.test.mjs

@@ -15,7 +15,9 @@ test('install.sh is a bash npm bootstrap with platform detection', () => {
   assert.match(source, /npm install --global/);
   assert.match(source, /Darwin-arm64/);
   assert.match(source, /--version/);
+  assert.match(source, /--app-id/);
   assert.match(source, /--app/);
+  assert.doesNotMatch(source, /APP_SELECTOR="\$\{AGENTSAM_DEFAULT_APP/);
   assert.match(source, /standalone_ready/);
   assert.match(source, /checksum_contract/);
 });
@@ -25,11 +27,12 @@ test('install.sh passes bash syntax validation', () => {
   assert.equal(result.status, 0, result.stderr);
 });
 
-test('install.sh maps --app aliases to executable launchers', () => {
+test('install.sh maps --app-id and legacy --app aliases to executable launchers', () => {
   const cases = [
     ['cad', 'cad-creator', 'agentsam-cad-creator'],
     ['cms', 'client-cms-editor', 'agentsam-cms'],
     ['studio', 'local-studio', 'agentsam-studio'],
+    ['database-editor', 'database-editor', 'agentsam-database-editor'],
   ];
 
   for (const [alias, appId, executable] of cases) {
@@ -57,7 +60,8 @@ test('install.sh maps --app aliases to executable launchers', () => {
     );
 
     try {
-      const result = spawnSync('bash', [installScript, '--app', alias, '--prefix', binDir], {
+      const flag = alias === 'database-editor' ? '--app-id' : '--app';
+      const result = spawnSync('bash', [installScript, flag, alias, '--prefix', binDir], {
         encoding: 'utf8',
         env: {
           ...process.env,
@@ -74,6 +78,7 @@ test('install.sh maps --app aliases to executable launchers', () => {
       assert.ok((fs.statSync(launcherPath).mode & 0o111) !== 0);
 
       const receipt = JSON.parse(fs.readFileSync(path.join(installRoot, 'install-receipt.json'), 'utf8'));
+      assert.equal(receipt.app_id, appId);
       assert.equal(receipt.app, appId);
     } finally {
       fs.rmSync(temp, { recursive: true, force: true });
@@ -81,13 +86,13 @@ test('install.sh maps --app aliases to executable launchers', () => {
   }
 });
 
-test('install.sh rejects unknown --app values before installation', () => {
-  const result = spawnSync('bash', [installScript, '--app', 'unknown'], { encoding: 'utf8' });
+test('install.sh rejects unknown --app-id values before installation', () => {
+  const result = spawnSync('bash', [installScript, '--app-id', 'unknown'], { encoding: 'utf8' });
   assert.equal(result.status, 2);
-  assert.match(result.stderr, /expected cad, cms, or studio/);
+  assert.match(result.stderr, /unknown app/);
 });
 
-test('Local Studio Worker serves standalone installer routes', () => {
+test('Local Studio Worker serves installer without AGENTSAM_DEFAULT_APP mutation', () => {
   const worker = fs.readFileSync(
     path.join(root, 'apps/local-studio/backend/worker/index.js'),
     'utf8',
@@ -98,9 +103,7 @@ test('Local Studio Worker serves standalone installer routes', () => {
   );
 
   assert.match(worker, /import installScript from "\.\.\/\.\.\/\.\.\/\.\.\/scripts\/install\.sh"/);
-  assert.match(worker, /"\/install\/cad": "cad-creator"/);
-  assert.match(worker, /"\/install\/cms": "client-cms-editor"/);
-  assert.match(worker, /"\/install\/studio": "local-studio"/);
+  assert.doesNotMatch(worker, /APP_SELECTOR="\\\$\{AGENTSAM_DEFAULT_APP/);
   assert.match(worker, /text\/x-shellscript/);
   assert.match(wrangler, /"type": "Text"/);
   assert.match(wrangler, /"\*\*\/\*\.sh"/);