refactor(release): drop release-policy.json runtime dep and next branch (#180)

* chore: standardize daemon naming on "KTX daemon"

Replace inconsistent names ("KTX Python daemon", "KTX local embeddings
daemon", "KTX managed daemon", "Python daemon") with the single name
"KTX daemon" in CLI output, errors, command descriptions, test
assertions, smoke scripts, docs, AGENTS.md, issue templates, and
codecov flags. The daemon is a portable compute server with endpoints
for SQL analysis, semantic layer, LookML, database introspection, and
embeddings; the previous labels misrepresented it as embeddings-only or
exposed implementation details ("Python", "managed").

The "KTX Python runtime" concept (installed interpreter + packages) is
deliberately left as-is — it is a separate concept from the daemon
process.

* refactor(release): drop release-policy.json runtime dep and next branch

Strips the release-policy.json fallback from release-version.ts so the CLI
reads its version straight from packages/cli/package.json. dev → 0.0.0-private,
installed @kaelio/ktx → the real semver baked into the published package.json.
KtxCliPackageInfo collapses to { name, version, contextPackageName }; /health
no longer depends on version files surviving past a CI run.

Replaces the dual-branch (main + next) semantic-release model with a single-
branch model on main. rcs and stables interleave on the same branch via
{ name: 'main', prerelease: 'rc', channel: 'next' } / ['main']. Drops
@semantic-release/git and @semantic-release/changelog (nothing is committed
back to the repo on any channel) and the workflow's "Prepare next prerelease
branch" step plus the KTX_PRERELEASE_BRANCH plumbing. The git tag plus the
published npm artifact carry the version forward.

Updates docs/release.md, removes the two now-unused devDeps, regenerates
pnpm-lock.yaml. 611/611 @ktx/cli tests, 173/173 script tests, type-check,
biome, knip all clean.

* fix(release): don't throw on non-main branches at config-load time

knip loads .releaserc.cjs on every PR run, where GITHUB_REF_NAME is the
merge ref (e.g. 180/merge). The previous version of releaseBranches threw
immediately when the branch wasn't main, which made knip fail to evaluate
the config and then mis-flag @semantic-release/exec as an unused dep.

semantic-release already refuses to publish when the current branch doesn't
match a configured release branch, so the explicit throw was redundant.
Drop it (and the unused currentBranch helper) and replace the
"rejects releases from non-main" assertion with one that exercises a CI-
shaped GITHUB_REF_NAME and confirms the config loads.

scripts/local-embeddings-runtime-smoke.mjs

@@ -346,7 +346,7 @@ export async function runLocalEmbeddingsRuntimeSmoke(options = {}) {
       900_000,
     );
     validateEmbeddingResponse(embeddingResponse, 384);
-    process.stdout.write('KTX local embeddings daemon computed a 384-dimensional embedding\n');
+    process.stdout.write('KTX daemon computed a 384-dimensional embedding\n');
 
     const setup = await run(commands[5].command, commands[5].args, {
       cwd: installDir,
@@ -369,7 +369,7 @@ export async function runLocalEmbeddingsRuntimeSmoke(options = {}) {
     });
     requireSuccess(commands[6].label, stop);
     daemonStarted = false;
-    requireOutput(commands[6].label, stop, /Stopped KTX Python daemon/);
+    requireOutput(commands[6].label, stop, /Stopped KTX daemon/);
 
     process.stdout.write('KTX local embeddings runtime smoke verified\n');
   } finally {

scripts/local-embeddings-runtime-smoke.test.mjs

@@ -129,13 +129,13 @@ describe('localEmbeddingsSmokeCommands', () => {
 describe('parseDaemonBaseUrl', () => {
   it('extracts the daemon URL from runtime start output', () => {
     assert.equal(
-      parseDaemonBaseUrl('Started KTX Python daemon\nurl: http://127.0.0.1:61234\nfeatures: local-embeddings\n'),
+      parseDaemonBaseUrl('Started KTX daemon\nurl: http://127.0.0.1:61234\nfeatures: local-embeddings\n'),
       'http://127.0.0.1:61234',
     );
   });
 
   it('rejects output without a daemon URL', () => {
-    assert.throws(() => parseDaemonBaseUrl('Started KTX Python daemon\n'), /Daemon URL was not printed/);
+    assert.throws(() => parseDaemonBaseUrl('Started KTX daemon\n'), /Daemon URL was not printed/);
   });
 });
 

scripts/package-artifacts.mjs

@@ -804,19 +804,19 @@ try {
   const runtimeStart = await run('pnpm', ['exec', 'ktx', 'admin', 'runtime', 'start']);
   requireSuccess('ktx admin runtime start', runtimeStart);
   daemonStarted = true;
-  requireOutput('ktx admin runtime start', runtimeStart, /Started KTX Python daemon/);
+  requireOutput('ktx admin runtime start', runtimeStart, /Started KTX daemon/);
   requireOutput('ktx admin runtime start', runtimeStart, /url: http:\\/\\/127\\.0\\.0\\.1:\\d+/);
   requireOutput('ktx admin runtime start', runtimeStart, /features: core/);
 
   const runtimeStartReuse = await run('pnpm', ['exec', 'ktx', 'admin', 'runtime', 'start']);
   requireSuccess('ktx admin runtime start reuse', runtimeStartReuse);
-  requireOutput('ktx admin runtime start reuse', runtimeStartReuse, /Using existing KTX Python daemon/);
+  requireOutput('ktx admin runtime start reuse', runtimeStartReuse, /Using existing KTX daemon/);
   requireOutput('ktx admin runtime start reuse', runtimeStartReuse, /features: core/);
 
   const runtimeStop = await run('pnpm', ['exec', 'ktx', 'admin', 'runtime', 'stop']);
   requireSuccess('ktx admin runtime stop', runtimeStop);
   daemonStarted = false;
-  requireOutput('ktx admin runtime stop', runtimeStop, /Stopped KTX Python daemon/);
+  requireOutput('ktx admin runtime stop', runtimeStop, /Stopped KTX daemon/);
   process.stdout.write('ktx admin runtime daemon lifecycle verified\\n');
 
   const structuralScan = await run('pnpm', ['exec', 'ktx', 'ingest', 'warehouse',

scripts/package-artifacts.test.mjs

@@ -502,7 +502,7 @@ describe('verification snippets', () => {
     assert.match(source, /status: ready/);
     assert.match(source, /ktx admin runtime start/);
     assert.match(source, /ktx admin runtime start reuse/);
-    assert.match(source, /Using existing KTX Python daemon/);
+    assert.match(source, /Using existing KTX daemon/);
     assert.match(source, /ktx admin runtime stop/);
     assert.doesNotMatch(source, /ktx admin runtime prune/);
     assert.doesNotMatch(source, /staleRuntimeDir/);

scripts/release-workflow.test.mjs

@@ -21,15 +21,14 @@ describe('release workflow', () => {
     assert.doesNotMatch(workflow, /Prepare first stable release floor/);
     assert.doesNotMatch(workflow, /git tag v0\.0\.0/);
     assert.doesNotMatch(workflow, /KTX_STABLE_RELEASE_FLOOR_TAG/);
-    assert.match(workflow, /Prepare next prerelease branch/);
-    assert.match(workflow, /git checkout -B "\$\{KTX_PRERELEASE_BRANCH\}"/);
+    assert.doesNotMatch(workflow, /Prepare next prerelease branch/);
+    assert.doesNotMatch(workflow, /KTX_PRERELEASE_BRANCH/);
+    assert.doesNotMatch(workflow, /GITHUB_REF="refs\/heads\//);
     assert.match(workflow, /Prepare npm package root for release verification/);
     assert.match(workflow, /dist\/public-npm-package\/package\.json/);
-    assert.match(workflow, /GITHUB_REF="refs\/heads\/\$\{KTX_PRERELEASE_BRANCH\}"/);
     assert.match(workflow, /pnpm run semantic-release:dry-run/);
     assert.match(workflow, /pnpm run semantic-release$/m);
     assert.match(workflow, /KTX_RELEASE_KIND: \$\{\{ inputs.release_kind \}\}/);
-    assert.match(workflow, /KTX_PRERELEASE_BRANCH: next/);
     assert.match(workflow, /FORCE_RELEASE: \$\{\{ inputs.force_release \}\}/);
     assert.doesNotMatch(workflow, /NODE_AUTH_TOKEN/);
     assert.doesNotMatch(workflow, /^  push:/m);

scripts/semantic-release-config.cjs

@@ -74,54 +74,22 @@ const releaseNoteTypes = [
   { type: 'major', section: 'BREAKING CHANGES', hidden: false },
 ];
 
-function currentBranch(env) {
-  return env.GITHUB_REF_NAME || env.INPUT_BRANCH || 'main';
-}
-
 function releaseKind(env) {
   return env.KTX_RELEASE_KIND || env.INPUT_RELEASE_KIND || 'rc';
 }
 
-function prereleaseBranch(env) {
-  return env.KTX_PRERELEASE_BRANCH || env.INPUT_PRERELEASE_BRANCH || 'next';
-}
-
 function releaseTag(kind) {
   return kind === 'rc' ? 'next' : 'latest';
 }
 
-function releaseChangelogPlugins(kind) {
-  return kind === 'rc' ? ['@semantic-release/changelog'] : [];
-}
-
-function releaseGitPlugins(kind) {
-  if (kind !== 'rc') {
-    return [];
-  }
-
-  return [
-    [
-      '@semantic-release/git',
-      {
-        assets: ['CHANGELOG.md', 'package.json', 'release-policy.json'],
-        message: 'chore(release): ${nextRelease.version} [skip ci]\n\n${nextRelease.notes}',
-      },
-    ],
-  ];
-}
-
 function releaseBranches(env = process.env) {
-  const branch = currentBranch(env);
   const kind = releaseKind(env);
 
   if (kind === 'rc') {
-    return ['main', { name: prereleaseBranch(env), prerelease: 'rc', channel: 'next' }];
+    return [{ name: 'main', prerelease: 'rc', channel: 'next' }];
   }
 
   if (kind === 'stable') {
-    if (branch !== 'main') {
-      throw new Error(`Stable KTX releases must run from main, got ${branch}`);
-    }
     return ['main'];
   }
 
@@ -157,7 +125,6 @@ function createReleaseConfig(env = process.env) {
           },
         },
       ],
-      ...releaseChangelogPlugins(kind),
       [
         '@semantic-release/exec',
         {
@@ -172,7 +139,6 @@ function createReleaseConfig(env = process.env) {
           ].join(' && '),
         },
       ],
-      ...releaseGitPlugins(kind),
       [
         '@semantic-release/github',
         {
@@ -188,7 +154,6 @@ function createReleaseConfig(env = process.env) {
 
 module.exports = {
   createReleaseConfig,
-  prereleaseBranch,
   releaseBranches,
   releaseKind,
   releaseTag,

scripts/semantic-release-config.test.mjs

@@ -9,21 +9,16 @@ function releaseExecOptions(config) {
   return config.plugins.find((plugin) => Array.isArray(plugin) && plugin[0] === '@semantic-release/exec' && plugin[1].prepareCmd)[1];
 }
 
-function releaseExecIndex(config) {
-  return config.plugins.findIndex((plugin) => Array.isArray(plugin) && plugin[0] === '@semantic-release/exec' && plugin[1].prepareCmd);
-}
-
 function pluginNames(config) {
   return config.plugins.map((plugin) => (Array.isArray(plugin) ? plugin[0] : plugin));
 }
 
 describe('semantic-release config', () => {
-  it('configures rc releases on a dedicated next prerelease branch', () => {
+  it('configures rc releases as a prerelease on main', () => {
     assert.equal(releaseKind({ KTX_RELEASE_KIND: 'rc' }), 'rc');
     assert.equal(releaseTag('rc'), 'next');
     assert.deepEqual(releaseBranches({ KTX_RELEASE_KIND: 'rc', GITHUB_REF_NAME: 'main' }), [
-      'main',
-      { name: 'next', prerelease: 'rc', channel: 'next' },
+      { name: 'main', prerelease: 'rc', channel: 'next' },
     ]);
 
     const config = createReleaseConfig({ KTX_RELEASE_KIND: 'rc', GITHUB_REF_NAME: 'main' });
@@ -42,14 +37,6 @@ describe('semantic-release config', () => {
     );
     assert.match(releaseExecOptions(config).publishCmd, /pnpm run release:published-smoke/);
     assert.doesNotMatch(JSON.stringify(config.plugins), /release:npm-publish/);
-    const releaseFilePluginNames = pluginNames(config).filter(
-      (plugin) => plugin === '@semantic-release/changelog' || plugin === '@semantic-release/git',
-    );
-    assert.deepEqual(releaseFilePluginNames, ['@semantic-release/changelog', '@semantic-release/git']);
-
-    const names = pluginNames(config);
-    assert.ok(names.indexOf('@semantic-release/changelog') < releaseExecIndex(config));
-    assert.ok(names.indexOf('@semantic-release/git') > releaseExecIndex(config));
   });
 
   it('configures stable releases only from main with latest tag', () => {
@@ -69,18 +56,22 @@ describe('semantic-release config', () => {
     assert.equal(config.plugins.includes('./scripts/semantic-release-version-policy.cjs'), false);
   });
 
-  it('does not commit release files back to protected main during stable releases', () => {
-    const config = createReleaseConfig({ KTX_RELEASE_KIND: 'stable', GITHUB_REF_NAME: 'main' });
-
-    assert.equal(pluginNames(config).includes('@semantic-release/git'), false);
-    assert.equal(pluginNames(config).includes('@semantic-release/changelog'), false);
+  it('never commits release files back to the repo', () => {
+    for (const kind of ['rc', 'stable']) {
+      const config = createReleaseConfig({ KTX_RELEASE_KIND: kind, GITHUB_REF_NAME: 'main' });
+      assert.equal(pluginNames(config).includes('@semantic-release/git'), false, `${kind}: @semantic-release/git`);
+      assert.equal(pluginNames(config).includes('@semantic-release/changelog'), false, `${kind}: @semantic-release/changelog`);
+    }
   });
 
-  it('rejects stable releases from non-main branches', () => {
-    assert.throws(
-      () => releaseBranches({ KTX_RELEASE_KIND: 'stable', GITHUB_REF_NAME: 'feature/release-test' }),
-      /Stable KTX releases must run from main, got feature\/release-test/,
-    );
+  it('produces a loadable config regardless of GITHUB_REF_NAME', () => {
+    // Knip and other tooling load .releaserc.cjs on PR runners where
+    // GITHUB_REF_NAME is the merge ref. semantic-release itself enforces the
+    // main-only rule by refusing to publish when the current branch does not
+    // match a configured release branch, so the config must not throw at load.
+    for (const kind of ['rc', 'stable']) {
+      assert.doesNotThrow(() => releaseBranches({ KTX_RELEASE_KIND: kind, GITHUB_REF_NAME: '180/merge' }));
+    }
   });
 
   it('keeps the force-release patch escape hatch', () => {