@treeseed/sdk 0.11.0 → 0.12.5

package/dist/scripts/template-catalog.test.js

@@ -4,97 +4,83 @@ import { mkdtempSync, mkdirSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join, resolve } from 'node:path';
 import { listTemplateProducts, resolveTemplateDefinition } from '../dist/scripts/template-registry-lib.js';
-
 function makeMachineConfigRoot(endpoint) {
-	const root = mkdtempSync(join(tmpdir(), 'treeseed-cli-template-catalog-'));
-	const configDir = resolve(root, '.treeseed', 'config');
-	mkdirSync(configDir, { recursive: true });
-	writeFileSync(resolve(configDir, 'machine.yaml'), [
-		'version: 1',
-		'settings:',
-		'  templates:',
-		`    catalogEndpoint: ${endpoint}`,
-		'',
-	].join('\n'), 'utf8');
-	return root;
+    const root = mkdtempSync(join(tmpdir(), 'treeseed-cli-template-catalog-'));
+    const configDir = resolve(root, '.treeseed', 'config');
+    mkdirSync(configDir, { recursive: true });
+    writeFileSync(resolve(configDir, 'machine.yaml'), [
+        'version: 1',
+        'settings:',
+        '  templates:',
+        `    catalogEndpoint: ${endpoint}`,
+        '',
+    ].join('\n'), 'utf8');
+    return root;
 }
-
 function writeCatalogFixture(root, fileName, items) {
-	const fixturePath = resolve(root, fileName);
-	writeFileSync(fixturePath, JSON.stringify({ items }, null, 2), 'utf8');
-	return fixturePath;
+    const fixturePath = resolve(root, fileName);
+    writeFileSync(fixturePath, JSON.stringify({ items }, null, 2), 'utf8');
+    return fixturePath;
 }
-
 function writeCatalogCache(root, endpoint, items) {
-	const cacheDir = resolve(root, '.treeseed', 'cache');
-	mkdirSync(cacheDir, { recursive: true });
-	writeFileSync(resolve(cacheDir, 'template-catalog.json'), JSON.stringify({
-		endpoint,
-		fetchedAt: '2026-04-08T00:00:00.000Z',
-		items,
-	}, null, 2), 'utf8');
+    const cacheDir = resolve(root, '.treeseed', 'cache');
+    mkdirSync(cacheDir, { recursive: true });
+    writeFileSync(resolve(cacheDir, 'template-catalog.json'), JSON.stringify({
+        endpoint,
+        fetchedAt: '2026-04-08T00:00:00.000Z',
+        items,
+    }, null, 2), 'utf8');
 }
-
 const starterTemplate = {
-	id: 'fixture-template',
-	displayName: 'Fixture Template',
-	description: 'Starter',
-	summary: 'Starter summary',
-	status: 'live',
-	category: 'starter',
-	publisher: {
-		id: 'treeseed',
-		name: 'TreeSeed',
-	},
-	templateVersion: '1.0.0',
-	templateApiVersion: 1,
-	minCliVersion: '0.1.1',
-	minCoreVersion: '0.1.2',
-	fulfillment: {
-		source: {
-			repoUrl: 'https://example.com/repo.git',
-			directory: 'templates/fixture-template',
-			ref: 'main',
-		},
-		hooksPolicy: 'builtin_only',
-		supportsReconcile: true,
-	},
+    id: 'fixture-template',
+    displayName: 'Fixture Template',
+    description: 'Starter',
+    summary: 'Starter summary',
+    status: 'live',
+    category: 'starter',
+    publisher: {
+        id: 'treeseed',
+        name: 'TreeSeed',
+    },
+    templateVersion: '1.0.0',
+    templateApiVersion: 1,
+    minCliVersion: '0.1.1',
+    minCoreVersion: '0.1.2',
+    fulfillment: {
+        source: {
+            repoUrl: 'https://example.com/repo.git',
+            directory: 'templates/fixture-template',
+            ref: 'main',
+        },
+        hooksPolicy: 'builtin_only',
+        supportsReconcile: true,
+    },
 };
-
 test('template registry reads the remote catalog from a configured file endpoint and falls back to cache', async () => {
-	const root = mkdtempSync(join(tmpdir(), 'treeseed-cli-template-catalog-fixture-'));
-	const fixturePath = writeCatalogFixture(root, 'catalog.json', [starterTemplate]);
-	const fallbackEndpoint = 'https://127.0.0.1:9/search/templates';
-	const cwd = makeMachineConfigRoot(`file:${fixturePath}`);
-
-	const remoteProducts = await listTemplateProducts({ cwd, env: {} });
-	assert.equal(remoteProducts.length, 1);
-	assert.equal(remoteProducts[0]?.id, 'fixture-template');
-
-	writeCatalogCache(cwd, fallbackEndpoint, [starterTemplate]);
-
-	const warnings = [];
-	const cachedProducts = await listTemplateProducts({
-		cwd,
-		env: {
-			TREESEED_TEMPLATE_CATALOG_URL: fallbackEndpoint,
-		},
-		writeWarning: (message) => warnings.push(message),
-	});
-
-	assert.equal(cachedProducts.length, 1);
-	assert.equal(cachedProducts[0]?.id, 'fixture-template');
-	assert.equal(warnings.length, 1);
-	assert.match(warnings[0], /Using cached template catalog/);
+    const root = mkdtempSync(join(tmpdir(), 'treeseed-cli-template-catalog-fixture-'));
+    const fixturePath = writeCatalogFixture(root, 'catalog.json', [starterTemplate]);
+    const fallbackEndpoint = 'https://127.0.0.1:9/search/templates';
+    const cwd = makeMachineConfigRoot(`file:${fixturePath}`);
+    const remoteProducts = await listTemplateProducts({ cwd, env: {} });
+    assert.equal(remoteProducts.length, 1);
+    assert.equal(remoteProducts[0]?.id, 'fixture-template');
+    writeCatalogCache(cwd, fallbackEndpoint, [starterTemplate]);
+    const warnings = [];
+    const cachedProducts = await listTemplateProducts({
+        cwd,
+        env: {
+            TREESEED_TEMPLATE_CATALOG_URL: fallbackEndpoint,
+        },
+        writeWarning: (message) => warnings.push(message),
+    });
+    assert.equal(cachedProducts.length, 1);
+    assert.equal(cachedProducts[0]?.id, 'fixture-template');
+    assert.equal(warnings.length, 1);
+    assert.match(warnings[0], /Using cached template catalog/);
 });
-
 test('template definition resolution rejects templates missing from the remote catalog', async () => {
-	const root = mkdtempSync(join(tmpdir(), 'treeseed-cli-template-catalog-empty-'));
-	const fixturePath = writeCatalogFixture(root, 'empty.json', []);
-	const cwd = makeMachineConfigRoot(`file:${fixturePath}`);
-
-	await assert.rejects(
-		() => resolveTemplateDefinition('fixture-template', { cwd, env: {} }),
-		/Unable to resolve remote template product "fixture-template"\./,
-	);
+    const root = mkdtempSync(join(tmpdir(), 'treeseed-cli-template-catalog-empty-'));
+    const fixturePath = writeCatalogFixture(root, 'empty.json', []);
+    const cwd = makeMachineConfigRoot(`file:${fixturePath}`);
+    await assert.rejects(() => resolveTemplateDefinition('fixture-template', { cwd, env: {} }), /Unable to resolve remote template product "fixture-template"\./);
 });

package/dist/scripts/tenant-dev.js

@@ -2,7 +2,6 @@ import { spawnSync } from 'node:child_process';
 import { corePackageRoot, packageScriptPath, spawnNodeBinary, resolveWranglerBin } from '../operations/services/runtime-tools.js';
 import { applyTreeseedEnvironmentToProcess, assertTreeseedCommandEnvironment } from '../operations/services/config-runtime.js';
 import { ensureGeneratedWranglerConfig } from '../operations/services/deploy.js';
-import { loadTreeseedDeployConfig } from '../platform/deploy-config.js';
 import { createTenantWatchEntries, isEditablePackageWorkspace, startPollingWatch, stopManagedProcess, writeDevReloadStamp, workspaceSdkRoot, } from '../operations/services/watch-dev.js';
 const tenantRoot = process.cwd();
 const cliArgs = process.argv.slice(2);
@@ -12,12 +11,6 @@ let wranglerChild = null;
 let stopWatching = null;
 let isStoppingForRebuild = false;
 let shuttingDown = false;
-function shouldEnsureMailpit() {
-    if (process.env.TREESEED_DEV_FORCE_MAILPIT === '1') {
-        return true;
-    }
-    return loadTreeseedDeployConfig().smtp?.enabled === true;
-}
 function runStep(command, args, { cwd = tenantRoot, env = {}, fatal = true } = {}) {
     const result = spawnSync(command, args, {
         stdio: 'inherit',
@@ -63,9 +56,6 @@ function runTenantBuildCycle({ includePackageBuild = false, includeSdkBuild = fa
         ['aggregate-book', []],
         ['tenant-d1-migrate-local', []],
     ];
-    if (shouldEnsureMailpit()) {
-        buildScripts.splice(2, 0, ['ensure-mailpit', []]);
-    }
     for (const [scriptName, args] of buildScripts) {
         const ok = runNodeScript(packageScriptPath(scriptName), args, { fatal });
         if (!ok) {

package/dist/scripts/test-cloudflare-local.js

@@ -107,7 +107,7 @@ async function submitSubscribeForm({ formToken, sessionId, cookieHeader }, email
     });
 }
 async function querySubscribers() {
-    const query = `SELECT lookup_key AS email, status, json_extract(payload_json, '$.source') AS source FROM runtime_records WHERE record_type = 'subscription' AND lookup_key = '${TEST_EMAIL}'`;
+    const query = `SELECT email, created_at FROM subscribers WHERE email = '${TEST_EMAIL}'`;
     const child = spawnProcess('wrangler', [
         'd1',
         'execute',

package/dist/scripts/test-scaffold.js

@@ -173,7 +173,6 @@ function linkTreeseedBins(siteRoot) {
     for (const [name, relativeTarget] of [
         ['treeseed', '../@treeseed/cli/dist/cli/main.js'],
         ['treeseed-agents', '../@treeseed/agent/dist/agents/cli.js'],
-        ['treeseed-agent-api', '../@treeseed/agent/dist/scripts/treeseed-agent-api.js'],
         ['treeseed-agent-service', '../@treeseed/agent/dist/scripts/treeseed-agent-service.js'],
     ]) {
         symlinkSync(relativeTarget, resolve(binRoot, name));

package/dist/scripts/test-smoke.js

@@ -123,9 +123,9 @@ try {
         private: true,
         type: 'module',
         scripts: {
-            'verify:direct': 'node --input-type=module -e "console.log(\'treeseed-sdk-smoke-verify\')"',
-            'verify:local': 'node --input-type=module -e "process.env.TREESEED_VERIFY_DRIVER=\'direct\'; console.log(\'treeseed-sdk-smoke-verify-local\')"',
-            'verify:action': 'node --input-type=module -e "process.env.TREESEED_VERIFY_DRIVER=\'act\'; console.log(\'treeseed-sdk-smoke-verify-action\')"',
+            'verify:direct': 'tsx -e "console.log(\'treeseed-sdk-smoke-verify\')"',
+            'verify:local': 'tsx -e "process.env.TREESEED_VERIFY_DRIVER=\'direct\'; console.log(\'treeseed-sdk-smoke-verify-local\')"',
+            'verify:action': 'tsx -e "process.env.TREESEED_VERIFY_DRIVER=\'act\'; console.log(\'treeseed-sdk-smoke-verify-action\')"',
         },
     }, null, 2)}\n`, 'utf8');
     run(process.execPath, ['--input-type=module', '-e', 'await import("@treeseed/sdk/verification");'], installRoot);

package/dist/scripts/treeseed-build-dist.js

@@ -1,5 +1,5 @@
 import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync, chmodSync } from 'node:fs';
-import { basename, dirname, extname, join, relative, resolve } from 'node:path';
+import { dirname, extname, join, relative, resolve } from 'node:path';
 import { build } from 'esbuild';
 import ts from 'typescript';
 import { packageRoot } from './package-tools.js';
@@ -44,7 +44,7 @@ function isTypeScriptSource(filePath) {
 }
 async function compileModule(filePath, sourceRoot, outputRoot) {
     const relativePath = relative(sourceRoot, filePath);
-    const outputFile = resolve(outputRoot, relativePath.replace(/\.(mjs|ts)$/u, '.js'));
+    const outputFile = resolve(outputRoot, relativePath.replace(/\.ts$/u, '.js'));
     ensureDir(outputFile);
     await build({
         entryPoints: [filePath],
@@ -71,12 +71,9 @@ function copyAssetTree(sourceRoot, outputRoot) {
     }
 }
 function transpileScript(filePath) {
-    if (basename(filePath).startsWith('.ts-run-')) {
-        return;
-    }
     const source = readFileSync(filePath, 'utf8');
     const relativePath = relative(scriptsRoot, filePath);
-    const outputFile = resolve(distRoot, 'scripts', relativePath.replace(/\.(mjs|ts)$/u, '.js'));
+    const outputFile = resolve(distRoot, 'scripts', relativePath.replace(/\.ts$/u, '.js'));
     const transformed = extname(filePath) === '.ts'
         ? ts.transpileModule(source, {
             compilerOptions: { module: ts.ModuleKind.ESNext, target: ts.ScriptTarget.ES2022 },
@@ -125,7 +122,7 @@ if (existsSync(templateCatalogSourceRoot)) {
 }
 for (const filePath of walkFiles(scriptsRoot)) {
     const extension = extname(filePath);
-    if (extension === '.ts' || extension === '.mjs')
+    if (extension === '.ts')
         transpileScript(filePath);
 }
 emitDeclarations();

package/dist/scripts/treeseed-release-verify.js

@@ -4,7 +4,7 @@ import { tmpdir } from 'node:os';
 import { dirname, extname, join, resolve } from 'node:path';
 import { spawnSync } from 'node:child_process';
 import { corePackageRoot, packageRoot, sdkPackageRoot } from '../operations/services/runtime-tools.js';
-const textExtensions = new Set(['.js', '.ts', '.mjs', '.cjs', '.d.js', '.json', '.md']);
+const textExtensions = new Set(['.js', '.ts', '.d.js', '.json', '.md']);
 const forbiddenPatterns = [
     /['"`]workspace:[^'"`\n]+['"`]/,
     /['"`](?:\.\.\/|\.\/)[^'"`\n]*src\/[^'"`\n]*\.(?:[cm]?js|ts|tsx|json|astro|css)['"`]/,

package/dist/scripts/verify-driver.js

@@ -1,36 +1,45 @@
 #!/usr/bin/env node
-
 import { existsSync } from 'node:fs';
 import { spawnSync } from 'node:child_process';
 import { dirname, resolve } from 'node:path';
+import { tmpdir } from 'node:os';
 import { fileURLToPath } from 'node:url';
-
 const scriptRoot = dirname(fileURLToPath(import.meta.url));
 const packageRoot = resolve(scriptRoot, '..');
-const sourceRunner = resolve(packageRoot, 'scripts', 'run-ts.mjs');
 const sourceEntry = resolve(packageRoot, 'src', 'verification.ts');
 const publishedEntry = resolve(packageRoot, 'dist', 'verification.js');
 const entrypointCheckOnly = process.env.TREESEED_VERIFY_ENTRYPOINT_CHECK === 'true';
-
-if (existsSync(sourceRunner) && existsSync(sourceEntry)) {
-	if (entrypointCheckOnly) {
-		process.exit(0);
-	}
-	const result = spawnSync(process.execPath, [sourceRunner, sourceEntry], {
-		cwd: process.cwd(),
-		env: process.env,
-		stdio: 'inherit',
-	});
-	process.exit(result.status ?? 1);
+function withShortTempEnv() {
+    if (process.platform === 'win32') {
+        return process.env;
+    }
+    const env = { ...process.env };
+    const shortTemp = tmpdir();
+    for (const key of ['TMPDIR', 'TMP', 'TEMP']) {
+        const value = env[key];
+        if (value && value.length > shortTemp.length) {
+            env[key] = shortTemp;
+        }
+    }
+    return env;
+}
+if (existsSync(sourceEntry)) {
+    if (entrypointCheckOnly) {
+        process.exit(0);
+    }
+    const result = spawnSync('tsx', [sourceEntry], {
+        cwd: process.cwd(),
+        env: withShortTempEnv(),
+        stdio: 'inherit',
+    });
+    process.exit(result.status ?? 1);
 }
-
 if (existsSync(publishedEntry)) {
-	if (entrypointCheckOnly) {
-		process.exit(0);
-	}
-	const { runTreeseedVerifyDriver } = await import('../dist/verification.js');
-	process.exit(runTreeseedVerifyDriver({ packageRoot: process.cwd() }));
+    if (entrypointCheckOnly) {
+        process.exit(0);
+    }
+    const { runTreeseedVerifyDriver } = await import('../dist/verification.js');
+    process.exit(runTreeseedVerifyDriver({ packageRoot: process.cwd() }));
 }
-
 process.stderr.write(`Unable to locate Treeseed SDK verification runtime from ${packageRoot}.\n`);
 process.exit(1);

package/dist/scripts/workflow-commands.test.js

@@ -1,40 +1,31 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
-import {
-	createBranchPreviewDeployTarget,
-	createPersistentDeployTarget,
-	deployTargetLabel,
-	loadDeployState,
-} from '../dist/scripts/deploy-lib.js';
+import { createBranchPreviewDeployTarget, createPersistentDeployTarget, deployTargetLabel, loadDeployState, } from '../dist/scripts/deploy-lib.js';
 import { renderDeployWebWorkflow } from '../dist/operations/services/github-automation.js';
 import { incrementVersion } from '../dist/scripts/workspace-save-lib.js';
 import { makeTenantRoot } from './cli-test-fixtures.js';
-
 test('persistent and branch targets produce distinct labels', () => {
-	assert.equal(deployTargetLabel(createPersistentDeployTarget('staging')), 'staging');
-	assert.equal(deployTargetLabel(createBranchPreviewDeployTarget('feature/one')), 'branch:feature/one');
+    assert.equal(deployTargetLabel(createPersistentDeployTarget('staging')), 'staging');
+    assert.equal(deployTargetLabel(createBranchPreviewDeployTarget('feature/one')), 'branch:feature/one');
 });
-
 test('branch preview state derives branch-specific worker names', () => {
-	const tenantRoot = makeTenantRoot();
-	const deployConfig = {
-		cloudflare: { accountId: 'fixture-cloudflare-account-id', workerName: 'treeseed-working-site' },
-	};
-	const state = loadDeployState(tenantRoot, deployConfig, { target: createBranchPreviewDeployTarget('feature/preview') });
-	assert.match(state.workerName, /^treeseed-working-site-feature-preview/);
-	assert.equal(state.previewEnabled, true);
+    const tenantRoot = makeTenantRoot();
+    const deployConfig = {
+        cloudflare: { accountId: 'fixture-cloudflare-account-id', workerName: 'treeseed-working-site' },
+    };
+    const state = loadDeployState(tenantRoot, deployConfig, { target: createBranchPreviewDeployTarget('feature/preview') });
+    assert.match(state.workerName, /^treeseed-working-site-feature-preview/);
+    assert.equal(state.previewEnabled, true);
 });
-
 test('deploy workflow exposes final web actions only', () => {
-	const webWorkflow = renderDeployWebWorkflow({ workingDirectory: '.' });
-	assert.match(webWorkflow, /default: deploy_web/);
-	assert.match(webWorkflow, /- publish_content/);
-	assert.doesNotMatch(webWorkflow, /RAILWAY_API_TOKEN/);
-	assert.doesNotMatch(webWorkflow, /deploy_processing/);
+    const webWorkflow = renderDeployWebWorkflow({ workingDirectory: '.' });
+    assert.match(webWorkflow, /default: deploy_web/);
+    assert.match(webWorkflow, /- publish_content/);
+    assert.doesNotMatch(webWorkflow, /RAILWAY_API_TOKEN/);
+    assert.doesNotMatch(webWorkflow, /deploy_processing/);
 });
-
 test('version bump utility supports major, minor, and patch', () => {
-	assert.equal(incrementVersion('1.2.3', 'patch'), '1.2.4');
-	assert.equal(incrementVersion('1.2.3', 'minor'), '1.3.0');
-	assert.equal(incrementVersion('1.2.3', 'major'), '2.0.0');
+    assert.equal(incrementVersion('1.2.3', 'patch'), '1.2.4');
+    assert.equal(incrementVersion('1.2.3', 'minor'), '1.3.0');
+    assert.equal(incrementVersion('1.2.3', 'major'), '2.0.0');
 });

package/dist/scripts/workspace-command-e2e.js

@@ -388,7 +388,7 @@ function resolveRepositorySlug(repoDir) {
 function isProductionLikeTarget(repository, siteUrl) {
     const productionRepositories = new Set(['knowledge-coop/market', 'treeseed-ai/market']);
     const normalizedSiteUrl = String(siteUrl ?? '').replace(/\/+$/u, '').toLowerCase();
-    return productionRepositories.has(repository) || ['https://treeseed.ai', 'https://www.treeseed.ai'].includes(normalizedSiteUrl);
+    return productionRepositories.has(repository) || ['https://treeseed.dev', 'https://www.treeseed.dev'].includes(normalizedSiteUrl);
 }
 async function waitForGitHubWorkflow(repository, headSha, { timeoutMs = 900000 } = {}) {
     const startedAt = Date.now();

package/dist/scripts/workspace-lint.js

@@ -1,9 +1,15 @@
 import { packageScriptPath } from '../operations/services/runtime-tools.js';
 import { packagesWithScript, run, workspaceRoot } from '../operations/services/workspace-tools.js';
 const root = workspaceRoot();
+process.stderr.write('[workspace-lint] markdown cleanup check start\n');
+const markdownStartedAt = Date.now();
 run(process.execPath, [packageScriptPath('cleanup-markdown'), '--check'], {
     cwd: root,
 });
+process.stderr.write(`[workspace-lint] markdown cleanup check complete after ${((Date.now() - markdownStartedAt) / 1000).toFixed(1)}s\n`);
 for (const pkg of packagesWithScript('lint', root)) {
+    const startedAt = Date.now();
+    process.stderr.write(`[workspace-lint] ${pkg.name ?? pkg.dir} lint start\n`);
     run('npm', ['run', 'lint'], { cwd: pkg.dir });
+    process.stderr.write(`[workspace-lint] ${pkg.name ?? pkg.dir} lint complete after ${((Date.now() - startedAt) / 1000).toFixed(1)}s\n`);
 }

package/dist/scripts/workspace-release-test.js

@@ -1,5 +1,90 @@
-import { sortWorkspacePackages, workspacePackages, run } from '../operations/services/workspace-tools.js';
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import { resolve } from 'node:path';
+import { sortWorkspacePackages, workspacePackages, workspaceRoot, run } from '../operations/services/workspace-tools.js';
 const packages = sortWorkspacePackages(workspacePackages());
+const root = workspaceRoot();
+function readProcessCommand(pid) {
+    try {
+        return readFileSync(`/proc/${pid}/cmdline`, 'utf8').replace(/\0/g, ' ').trim()
+            || readFileSync(`/proc/${pid}/comm`, 'utf8').trim();
+    }
+    catch {
+        return '';
+    }
+}
+function processFdCount(pid) {
+    try {
+        return readdirSync(`/proc/${pid}/fd`).length;
+    }
+    catch {
+        return null;
+    }
+}
+function runningProcesses() {
+    if (!existsSync('/proc')) {
+        return [];
+    }
+    return readdirSync('/proc')
+        .filter((entry) => /^\d+$/u.test(entry))
+        .map((pid) => ({
+        pid: Number(pid),
+        fdCount: processFdCount(pid),
+        command: readProcessCommand(pid),
+    }))
+        .filter((entry) => entry.command.length > 0);
+}
+function terminate(pid, signal) {
+    try {
+        process.kill(pid, signal);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function cleanupStaleWorkspaceVerificationProcesses() {
+    const normalizedRoot = resolve(root);
+    const stale = runningProcesses().filter((entry) => {
+        const command = entry.command;
+        if (!command.includes('/.treeseed/worktrees/') || command.includes(normalizedRoot)) {
+            return false;
+        }
+        return /(vitest|release-verify|src\/verification\.ts|workspace-release-test)/u.test(command);
+    });
+    if (stale.length === 0) {
+        return;
+    }
+    process.stderr.write(`[workspace-release-test] stopping ${stale.length} stale sibling worktree verification process(es) before release tests\n`);
+    for (const entry of stale) {
+        process.stderr.write(`[workspace-release-test] SIGTERM stale pid ${entry.pid}: ${entry.command.slice(0, 180)}\n`);
+        terminate(entry.pid, 'SIGTERM');
+    }
+    spawnSync(process.execPath, ['-e', 'setTimeout(() => {}, 1000)'], { stdio: 'ignore' });
+    for (const entry of stale) {
+        try {
+            process.kill(entry.pid, 0);
+            process.stderr.write(`[workspace-release-test] SIGKILL stale pid ${entry.pid}: ${entry.command.slice(0, 180)}\n`);
+            terminate(entry.pid, 'SIGKILL');
+        }
+        catch {
+            // Process exited after SIGTERM.
+        }
+    }
+}
+function writeFdDiagnostic(label) {
+    const rows = runningProcesses()
+        .filter((entry) => (entry.fdCount ?? 0) >= 80)
+        .sort((left, right) => (right.fdCount ?? 0) - (left.fdCount ?? 0))
+        .slice(0, 10);
+    if (rows.length === 0) {
+        process.stderr.write(`[workspace-release-test] fd ${label}: no process with >=80 open descriptors\n`);
+        return;
+    }
+    process.stderr.write(`[workspace-release-test] fd ${label}: ${rows.map((entry) => `${entry.pid}:${entry.fdCount}:${entry.command.slice(0, 80)}`).join(' | ')}\n`);
+}
+cleanupStaleWorkspaceVerificationProcesses();
+writeFdDiagnostic('before');
 for (const pkg of packages) {
     const scripts = pkg.packageJson.scripts ?? {};
     const scriptName = typeof scripts['test:release'] === 'string'
@@ -10,6 +95,10 @@ for (const pkg of packages) {
                 ? 'test'
                 : null;
     if (scriptName) {
+        const startedAt = Date.now();
+        process.stderr.write(`[workspace-release-test] ${pkg.name ?? pkg.dir} ${scriptName} start\n`);
         run('npm', ['run', scriptName], { cwd: pkg.dir });
+        process.stderr.write(`[workspace-release-test] ${pkg.name ?? pkg.dir} ${scriptName} complete after ${((Date.now() - startedAt) / 1000).toFixed(1)}s\n`);
+        writeFdDiagnostic(`after ${pkg.name ?? pkg.dir}`);
     }
 }

package/dist/scripts/workspace-test.js

@@ -2,10 +2,16 @@ import { sortWorkspacePackages, workspacePackages, run } from '../operations/ser
 const packages = sortWorkspacePackages(workspacePackages());
 for (const pkg of packages) {
     if (typeof pkg.packageJson.scripts?.['test:unit'] === 'string') {
+        const startedAt = Date.now();
+        process.stderr.write(`[workspace-test] ${pkg.name ?? pkg.dir} test:unit start\n`);
         run('npm', ['run', 'test:unit'], { cwd: pkg.dir });
+        process.stderr.write(`[workspace-test] ${pkg.name ?? pkg.dir} test:unit complete after ${((Date.now() - startedAt) / 1000).toFixed(1)}s\n`);
         continue;
     }
     if (typeof pkg.packageJson.scripts?.test === 'string') {
+        const startedAt = Date.now();
+        process.stderr.write(`[workspace-test] ${pkg.name ?? pkg.dir} test start\n`);
         run('npm', ['run', 'test'], { cwd: pkg.dir });
+        process.stderr.write(`[workspace-test] ${pkg.name ?? pkg.dir} test complete after ${((Date.now() - startedAt) / 1000).toFixed(1)}s\n`);
     }
 }

package/dist/sdk-dispatch.d.ts

@@ -1,4 +1,4 @@
-import type { AgentSdk } from './sdk.ts';
+import type { AgentSdk } from './sdk.js';
 type JsonRecord = Record<string, unknown>;
 type SdkOperationHandler = (sdk: AgentSdk, input: JsonRecord) => Promise<unknown> | unknown;
 interface SdkOperationSpec {

package/dist/sdk-dispatch.js

@@ -23,22 +23,6 @@ const SDK_OPERATION_SPECS = [
   },
   { name: "startWorkDay", aliases: ["start-work-day"], handler: passthrough("startWorkDay") },
   { name: "closeWorkDay", aliases: ["close-work-day"], handler: passthrough("closeWorkDay") },
-  { name: "createTask", aliases: ["create-task"], handler: passthrough("createTask") },
-  { name: "claimTask", aliases: ["claim-task"], handler: passthrough("claimTask") },
-  {
-    name: "recordTaskProgress",
-    aliases: ["record-task-progress"],
-    handler: passthrough("recordTaskProgress")
-  },
-  { name: "completeTask", aliases: ["complete-task"], handler: passthrough("completeTask") },
-  { name: "failTask", aliases: ["fail-task"], handler: passthrough("failTask") },
-  { name: "appendTaskEvent", aliases: ["append-task-event"], handler: passthrough("appendTaskEvent") },
-  { name: "searchTasks", aliases: ["search-tasks"], handler: passthrough("searchTasks") },
-  {
-    name: "getManagerContext",
-    aliases: ["get-manager-context"],
-    handler: (sdk, input) => sdk.getManagerContext(String(input.taskId ?? input.id ?? ""))
-  },
   { name: "createReport", aliases: ["create-report"], handler: passthrough("createReport") },
   {
     name: "listAgentSpecs",

package/dist/sdk-fields.d.ts

@@ -1,4 +1,4 @@
-import type { SdkModelDefinition, SdkModelFieldBinding, SdkSortSpec, SdkFilterCondition } from './sdk-types.ts';
+import type { SdkModelDefinition, SdkModelFieldBinding, SdkSortSpec, SdkFilterCondition } from './sdk-types.js';
 export declare function validateModelFieldAliases(definition: SdkModelDefinition): void;
 export declare function resolveModelField(definition: SdkModelDefinition, requestedField: string): SdkModelFieldBinding;
 export declare function readCanonicalFieldValue(definition: SdkModelDefinition, record: Record<string, unknown>, canonicalField: string): unknown;

package/dist/sdk-filters.d.ts

@@ -1,4 +1,4 @@
-import type { SdkContentEntry, SdkFilterCondition, SdkModelDefinition, SdkSortSpec } from './sdk-types.ts';
+import type { SdkContentEntry, SdkFilterCondition, SdkModelDefinition, SdkSortSpec } from './sdk-types.js';
 export declare function matchesFilter(entry: SdkContentEntry | Record<string, unknown>, filter: SdkFilterCondition, definition?: SdkModelDefinition): boolean;
 export declare function applyFilters<T extends SdkContentEntry | Record<string, unknown>>(items: T[], filters?: SdkFilterCondition[], definition?: SdkModelDefinition): T[];
 export declare function applySort<T extends SdkContentEntry | Record<string, unknown>>(items: T[], sort?: SdkSortSpec[], definition?: SdkModelDefinition): T[];