dsh-workspace-mover 2.4.1 → 2.4.3

package/test/live-migration.test.mjs

@@ -0,0 +1,253 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, rmSync, readFileSync } from 'node:fs';
+import { runInNewContext } from 'node:vm';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import * as mover from '../lib/index.js';
+import { installLifecycle, lifecycleFor, withReleasedSession } from '../lib/lifecycle.js';
+
+test('live lifecycle: explicit stop, request exclusion, failure recovery and unload', async () => {
+	const entries = new Map();
+	let teardown;
+	const agents = {
+		get: (id) => entries.get(id),
+		async resume({ resumeSessionId: id }) {
+			const agent = { id, status: 'running', session: { header: {} }, send() { return 'sent'; } };
+			entries.set(id, agent);
+			return { agent, async dispose() { await teardown?.(); entries.delete(id); } };
+		}
+	};
+	let off;
+	const ctx = { agents, get: (key) => key === 'agents' ? agents : null };
+	installLifecycle(ctx, { agents, effect(fn) { off = fn(); } });
+	const { agent } = await agents.resume({ resumeSessionId: 'a' });
+	await assert.rejects(withReleasedSession(ctx, 'a', false, () => assert.fail()), { code: 'stop-required' });
+	assert.equal(agent.send(), 'sent');
+	teardown = async () => {
+		assert.throws(() => agent.send(), { code: 'migration-in-progress' });
+		await assert.rejects(agents.resume({ resumeSessionId: 'a' }), { code: 'migration-in-progress' });
+	};
+	await assert.rejects(withReleasedSession(ctx, 'a', true, () => { throw new Error('disk failure'); }), /disk failure/);
+	assert.equal(lifecycleFor(ctx, 'a'), null);
+	assert.throws(() => agent.send(), { code: 'migration-in-progress' });
+	const next = await agents.resume({ resumeSessionId: 'a' });
+	assert.equal(next.agent.send(), 'sent');
+	off();
+	assert.equal(lifecycleFor(ctx, 'a'), null);
+});
+
+test('delete lifecycle: no reload on success, restore after failure only when archive survives', async () => {
+	const entries = new Map();
+	let reloads = 0;
+	let teardown;
+	const agents = {
+		get: (id) => entries.get(id),
+		async resume({ resumeSessionId: id }) {
+			const agent = { id, status: 'idle', session: { header: {} }, send() {} };
+			entries.set(id, agent);
+			return { agent, async dispose() { entries.delete(id); } };
+		}
+	};
+	const ctx = { get: (key) => key === 'agents' ? agents : key === 'sessionController' ? {
+		async resolveAgent(id) { reloads++; return agents.resume({ resumeSessionId: id }); }
+	} : null };
+	installLifecycle(ctx, { agents, effect(fn) { teardown = fn(); } });
+	try {
+		await agents.resume({ resumeSessionId: 'delete' });
+		await withReleasedSession(ctx, 'delete', false, () => 'deleted', { reloadOnSuccess: false });
+		assert.equal(entries.has('delete'), false);
+		assert.equal(reloads, 0, 'never recreate the deleted conversation');
+		await agents.resume({ resumeSessionId: 'rollback' });
+		await assert.rejects(withReleasedSession(ctx, 'rollback', false, () => { throw new Error('rollback complete'); },
+			{ reloadOnSuccess: false, canReload: () => true }), /rollback complete/);
+		assert.equal(reloads, 1);
+		assert.ok(entries.has('rollback'));
+		await assert.rejects(withReleasedSession(ctx, 'rollback', false, () => { throw new Error('archive unavailable'); },
+			{ reloadOnSuccess: false, canReload: () => false }), /archive unavailable/);
+		assert.equal(reloads, 1, 'failed physical rollback must not create a blank session');
+	} finally { teardown(); }
+});
+
+const modules = process.env.DSH_TEST_NODE_MODULES;
+const load = (name) => import(pathToFileURL(join(resolve(modules), '@deepseek-ai', name, 'lib/index.js')).href);
+
+test('installed LocaleRuntime: bind follows locale changes and disposers unregister dictionaries',
+	{ skip: !modules }, () => {
+	const file = join(resolve(modules), '@deepseek-ai/dsh-client-locale/lib/client.js');
+	let exported;
+	runInNewContext(readFileSync(file, 'utf8'), {
+		window: { __ModuleLoader__: { load({ factory }) { exported = factory(() => ({})); } } },
+		navigator: { language: 'zh-CN', languages: ['zh-CN'] }, console
+	});
+	const locale = new exported.LocaleRuntime({ emit() {} }, undefined, { languages: ['en'], preference: 'en' });
+	const stop = locale.register('test-mover', { en: { title: 'Move {n}' }, zh: { title: '移动 {n}' } });
+	const t = locale.bind('test-mover');
+	assert.equal(t('title', { n: 2 }), 'Move 2');
+	let changed = 0;
+	const unsubscribe = locale.subscribe(() => changed++);
+	locale.setLocale('zh');
+	assert.equal(t('title', { n: 2 }), '移动 2');
+	assert.equal(changed, 1);
+	unsubscribe(); stop();
+	assert.equal(t('title'), 'title');
+});
+
+test('installed client Controller: a Provider reference keeps the removed generation alive until released',
+	{ skip: !modules, timeout: 10000 }, async () => {
+	const cordis = await load('cordis');
+	// Execute installed client logic, exposing the otherwise bundle-local class
+	// only inside this test. Renderer stores/transport are inert fixtures; actual
+	// Controller retention, scope retirement and Session flags are unmodified.
+	const file = join(resolve(modules), '@deepseek-ai/dsh-api-session-controller/lib/client.js');
+	const source = readFileSync(file, 'utf8').replace('exports.apply = apply;', 'exports.__ClientSessions = ClientSessions; exports.apply = apply;');
+	let exports;
+	const store = {
+		notifySubscribers(listeners) { for (const listener of [...listeners]) listener(); },
+		createSnapshotStore(initial) {
+			let value = initial;
+			const listeners = new Set();
+			return { getSnapshot: () => value,
+				subscribe(fn) { listeners.add(fn); return () => listeners.delete(fn); },
+				set(next) { value = next; store.notifySubscribers(listeners); } };
+		}
+	};
+	runInNewContext(source, { window: { __ModuleLoader__: { load({ factory }) {
+		exports = factory((name) => {
+			if (name === '@deepseek-ai/cordis') return cordis;
+			if (name === '@deepseek-ai/dsh-client-store') return store;
+			if (name === '@deepseek-ai/dsh-api-gateway/client') return { RemoteJournalStream: class {} };
+			throw new Error(`Unexpected client dependency: ${name}`);
+		});
+	} } }, console, AbortController, AbortSignal, queueMicrotask, setTimeout, clearTimeout });
+	const root = new cordis.Context();
+	try {
+		let listed = [];
+		let listCalls = 0;
+		const client = new exports.__ClientSessions(root, { session: {
+			async list() { listCalls++; return { ok: true, value: { items: listed } }; }
+		} });
+		const id = 'session-retained-view';
+		const summary = { sessionId: id, blank: false, running: false, agentAvailable: true, updatedAt: 1 };
+		client.handleSessionAdded(summary);
+		const main = client.retainAgentScope(id);
+		const provider = client.retainAgentScope(id);
+		const previous = main.binding;
+		client.handleSessionRemoved(id);
+		client.handleSessionAdded(summary);
+		assert.equal(previous.session.getSnapshot().removed, true, 'host resume does not clear the flag');
+		main.release();
+		const premature = client.retainAgentScope(id);
+		assert.equal(premature.binding, previous, 'immediate reopen reuses the removed instance');
+		premature.release();
+		await new Promise((resolve) => {
+			const stop = client.retainInfo(id).subscribe(() => {
+				if (client.binding(id) !== previous) { stop(); resolve(); }
+			});
+			setTimeout(() => provider.release(), 0);
+		});
+		const fresh = client.retainAgentScope(id);
+		assert.notEqual(fresh.binding, previous);
+		assert.equal(fresh.binding.session.getSnapshot().removed, false);
+		fresh.release();
+		client.handleSessionRemoved(id);
+		await new Promise((resolve) => setTimeout(resolve, 0));
+		assert.equal(client.list.getSnapshot().ids.includes(id), false);
+		listed = [summary];
+		await client.refresh();
+		await new Promise((resolve) => setTimeout(resolve, 0));
+		assert.equal(listCalls, 1);
+		assert.equal(client.list.getSnapshot().ids.includes(id), true,
+			'public refresh restores cold archive metadata without an Agent-created event or restart');
+	} finally {
+		await root.fiber.dispose();
+	}
+});
+
+test('installed DSH AgentLoop: dispose writer, physical move, resume same session and append',
+	{ skip: !modules, timeout: 30000 }, async () => {
+	const { Context } = await load('cordis');
+	const { default: Agents } = await load('dsh-agent');
+	const { default: Sessions } = await load('dsh-session');
+	const { default: Projections } = await load('dsh-session-projection');
+	const { default: Loop } = await load('dsh-agent-loop');
+	const persistence = await load('dsh-session-persistence-jsonl');
+	const home = mkdtempSync(join(tmpdir(), 'wsm-live-'));
+	const prior = process.env.DSH_HOME;
+	process.env.DSH_HOME = home;
+	const root = new Context();
+	const a = join(home, 'a'), b = join(home, 'b');
+	mkdirSync(a); mkdirSync(b);
+	const groups = ['a', 'b'].map((id, i) => ({ id, path: [a,b][i], record: { sessionIds: [] },
+		async attachSession(id) { this.record.sessionIds.push(id); },
+		async detachSession(id) { this.record.sessionIds = this.record.sessionIds.filter((x) => x !== id); } }));
+	try {
+		root.provide('workspaceRegistry', { list: () => groups, get: (id) => groups.find((x) => x.id === id) });
+		root.provide('llm', {});
+		root.provide('tools', {});
+		root.provide('systemPrompt', { variable() {}, assemble() { return []; } });
+		for (const plugin of [Sessions, Agents, Projections]) await root.plugin(plugin).await();
+		await root.plugin(persistence, { root: join(home, 'sessions'), compression: 'zstd' }).await();
+		await root.plugin({ name: 'lifecycle-observer', inject: ['agents'], apply(ctx) { installLifecycle(ctx, ctx); } }).await();
+		await root.plugin(Loop, { agents: [], maxParallelToolCalls: 1 }).await();
+		const agents = root.get('agents');
+		root.provide('sessionController', { async resolveAgent(id) {
+			return { agent: agents.get(id) ?? (await agents.resume({ resumeSessionId: id, agentOptions: {} })).agent };
+		} });
+		const id = 'session-live-test';
+		const first = await agents.create({ sessionId: id, meta: { cwd: a }, agentOptions: {} });
+		first.agent.session.append('working-directory/change', { cwd: a });
+		groups[0].record.sessionIds.push(id);
+		assert.ok(lifecycleFor(root, id), 'real public lifecycle handle was captured');
+		const moved = await mover.moveSessionEntry(root, { sessionId: id, targetWorkspaceId: 'b' });
+		assert.equal(moved.verified, true);
+		assert.equal(root.get('sessions').get(id).header.cwd, b, 'controller restores from the actual target');
+		const resumed = lifecycleFor(root, id).handle;
+		assert.equal(resumed.agent.session.header.cwd, b);
+		resumed.agent.session.append('working-directory/change', { cwd: b });
+		const attach = groups[0].attachSession;
+		groups[0].attachSession = async () => { throw new Error('injected attach failure'); };
+		await assert.rejects(mover.moveSessionEntry(root, { sessionId: id, targetWorkspaceId: 'a' }), /rolled back cleanly/);
+		assert.equal(agents.get(id).session.header.cwd, b, 'failed move reloads the original workspace');
+		groups[0].attachSession = attach;
+		const recovered = lifecycleFor(root, id).handle;
+		recovered.agent.session.append('working-directory/change', { cwd: b });
+		await recovered.dispose();
+		const read = await root.get('sessionPersistence').open(id, 'read');
+		assert.equal((await read.read()).events.at(-1).data.cwd, b);
+		await read.close();
+		// Exercise cancellation of a real running driver without a model call.
+		const active = await agents.resume({ resumeSessionId: id, agentOptions: {} });
+		let entered;
+		const started = new Promise((resolve) => { entered = resolve; });
+		const off = root.on('agent/pre-step', async ({ signal }) => {
+			entered();
+			await new Promise((resolve) => {
+				if (signal.aborted) resolve();
+				else signal.addEventListener('abort', resolve, { once: true });
+			});
+			return { kind: 'reject' };
+		});
+		active.agent.followup({ role: 'user', source: { kind: 'user' }, content: [{ type: 'text', text: 'test' }] });
+		await started;
+		assert.equal(active.agent.status, 'running');
+		await assert.rejects(mover.moveSessionEntry(root, { sessionId: id, targetWorkspaceId: 'a' }), { code: 'stop-required' });
+		assert.equal(active.agent.status, 'running', 'refusal does not stop the task');
+		const back = await mover.moveSessionEntry(root, { sessionId: id, targetWorkspaceId: 'a', stopRunning: true });
+		assert.equal(back.verified, true);
+		assert.equal(agents.get(id).session.header.cwd, a);
+		off();
+		const again = lifecycleFor(root, id).handle;
+		assert.equal(again.agent.session.header.cwd, a);
+		const deleted = await mover.deleteSessionToTrash(root, { sessionId: id });
+		assert.equal(deleted.deleted, true);
+		assert.equal(agents.get(id), undefined, 'deleted Agent is not reloaded');
+		assert.equal(root.get('sessions').get(id), undefined, 'real Session writer is released');
+		assert.equal(lifecycleFor(root, id), null);
+	} finally {
+		await root.fiber.dispose();
+		if (prior === undefined) delete process.env.DSH_HOME; else process.env.DSH_HOME = prior;
+		rmSync(home, { recursive: true, force: true, maxRetries: 3 });
+	}
+});

package/test/release-downloads.test.mjs

@@ -1,102 +1,102 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { execFileSync } from 'node:child_process';
-import { fileURLToPath } from 'node:url';
-import { applyReleaseBadgeToMarkdown, buildReleaseBadgeFiles, RELEASE_BADGE_END, RELEASE_BADGE_START, sanitizeGistPatchFiles, summarizeReleaseAssets } from '../.github/scripts/release-downloads-core.mjs';
-
-const gistId = 'c14345658550a4a308570acfbaf9d170';
-
-test('counts prefixed tgz/zip assets and hides the badge at 10 or fewer downloads', () => {
-	const summary = summarizeReleaseAssets([
-		{
-			tag_name: 'v1.4.2',
-			assets: [
-				{ name: 'dsh-workspace-mover-1.4.2.tgz', download_count: 6 },
-				{ name: 'dsh-workspace-mover-1.4.2.zip', download_count: 4 },
-				{ name: 'source.tar.gz', download_count: 99 }
-			]
-		}
-	]);
-	assert.equal(summary.total, 10);
-	assert.equal(summary.visible, false);
-	assert.equal(summary.assets.length, 2);
-});
-
-test('shows a shields.io endpoint badge only after the total exceeds 10', () => {
-	const summary = summarizeReleaseAssets([
-		{ tag_name: 'v2.0.0', assets: [{ name: 'dsh-workspace-mover-2.0.0.tgz', download_count: 11 }] }
-	]);
-	assert.equal(summary.visible, true);
-	const files = buildReleaseBadgeFiles({ total: summary.total, assets: summary.assets, updatedAt: '2026-09-10T00:00:00Z', visible: summary.visible });
-	const badge = JSON.parse(files['wsm-release-downloads.json'].content);
-	assert.equal(badge.label, 'Release downloads');
-	assert.equal(badge.message, '11');
-	assert.equal(badge.color, 'blue');
-	assert.equal(files['wsm-release-downloads.svg'], null);
-});
-
-test('hidden state deletes gist SVG and shields files so GitHub cannot render a broken alt-text link', () => {
-	const files = buildReleaseBadgeFiles({ total: 3, assets: [], updatedAt: '2026-09-10T00:00:00Z', visible: false });
-	assert.equal(files['wsm-release-downloads.json'], null);
-	assert.equal(files['wsm-release-downloads.svg'], null);
-	const data = JSON.parse(files['wsm-release-downloads-data.json'].content);
-	assert.equal(data.total, 3);
-	assert.equal(data.visible, false);
-});
-
-test('sanitizeGistPatchFiles skips deletes for files that are not on the gist', () => {
-	const patch = buildReleaseBadgeFiles({ total: 3, assets: [], updatedAt: '2026-09-10T00:00:00Z', visible: false });
-	const sanitized = sanitizeGistPatchFiles({ 'wsm-release-downloads-data.json': { content: '{}' } }, patch);
-	assert.deepEqual(Object.keys(sanitized).sort(), ['wsm-release-downloads-data.json']);
-	assert.equal(sanitized['wsm-release-downloads.json'], undefined);
-	assert.equal(sanitized['wsm-release-downloads.svg'], undefined);
-
-	const withExisting = sanitizeGistPatchFiles(
-		{
-			'wsm-release-downloads-data.json': { content: '{}' },
-			'wsm-release-downloads.json': { content: '{}' },
-			'wsm-clones-14d.json': { content: 'x' }
-		},
-		{ ...patch, 'wsm-clones-14d.json': null }
-	);
-	assert.equal(withExisting['wsm-release-downloads.json'], null);
-	assert.equal(withExisting['wsm-release-downloads.svg'], undefined);
-	assert.equal(withExisting['wsm-clones-14d.json'], null);
-	assert.equal(typeof withExisting['wsm-release-downloads-data.json'].content, 'string');
-});
-
-test('sanitizeGistPatchFiles turns empty content into a delete only when the file exists', () => {
-	const empty = sanitizeGistPatchFiles({}, { 'a.json': { content: '' } });
-	assert.deepEqual(empty, {});
-	const present = sanitizeGistPatchFiles({ 'a.json': { content: 'x' } }, { 'a.json': { content: '' } });
-	assert.deepEqual(present, { 'a.json': null });
-});
-
-test('README keeps an invisible marker below 10 and a shields graphic above 10', () => {
-	const source = [
-		'<p>',
-		'    <img alt="GitHub clones observed" src="https://img.shields.io/endpoint?url=https%3A%2F%2Fgist.githubusercontent.com%2FPianoPrince%2Fc14345658550a4a308570acfbaf9d170%2Fraw%2Fwsm-clones-total.json" style="height:20px; margin:0 2px;" />',
-		'    <img alt="Release downloads (shown after 10 downloads)" src="https://gist.githubusercontent.com/PianoPrince/c14345658550a4a308570acfbaf9d170/raw/wsm-release-downloads.svg" style="height:20px; margin:0 2px;" />',
-		'</p>'
-	].join('\n');
-	const hidden = applyReleaseBadgeToMarkdown(source, { visible: false, gistId });
-	assert.equal(hidden.includes('wsm-release-downloads.svg'), false);
-	assert.equal(hidden.includes('Release downloads (shown after 10 downloads)'), false);
-	assert.equal(hidden.includes('<img alt="Release downloads"'), false);
-	assert.equal(hidden.includes(RELEASE_BADGE_START), true);
-	assert.equal(hidden.includes(RELEASE_BADGE_END), true);
-	const shown = applyReleaseBadgeToMarkdown(hidden, { visible: true, gistId });
-	assert.equal(shown.includes('img.shields.io/endpoint?url='), true);
-	assert.equal(shown.includes('wsm-release-downloads.json'), true);
-	assert.equal(shown.includes('wsm-release-downloads.svg'), false);
-	assert.equal(shown.includes('<img alt="Release downloads"'), true);
-});
-
-test('extract-changelog accepts both current and historical heading styles', () => {
-        const script = fileURLToPath(new URL('../.github/scripts/extract-changelog.mjs', import.meta.url));
-        const current = execFileSync(process.execPath, [script, 'v2.0.1'], { encoding: 'utf8' });
-        const historical = execFileSync(process.execPath, [script, 'v1.4.2'], { encoding: 'utf8' });
-        assert.match(current, /Compatible with DeepSeek Harness/);
-        assert.match(historical, /GitHub Release tags now publish/);
-        assert.doesNotMatch(historical, /Compatible with DeepSeek Harness/);
-});
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { execFileSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { applyReleaseBadgeToMarkdown, buildReleaseBadgeFiles, RELEASE_BADGE_END, RELEASE_BADGE_START, sanitizeGistPatchFiles, summarizeReleaseAssets } from '../.github/scripts/release-downloads-core.mjs';
+
+const gistId = 'c14345658550a4a308570acfbaf9d170';
+
+test('counts prefixed tgz/zip assets and hides the badge at 10 or fewer downloads', () => {
+	const summary = summarizeReleaseAssets([
+		{
+			tag_name: 'v1.4.2',
+			assets: [
+				{ name: 'dsh-workspace-mover-1.4.2.tgz', download_count: 6 },
+				{ name: 'dsh-workspace-mover-1.4.2.zip', download_count: 4 },
+				{ name: 'source.tar.gz', download_count: 99 }
+			]
+		}
+	]);
+	assert.equal(summary.total, 10);
+	assert.equal(summary.visible, false);
+	assert.equal(summary.assets.length, 2);
+});
+
+test('shows a shields.io endpoint badge only after the total exceeds 10', () => {
+	const summary = summarizeReleaseAssets([
+		{ tag_name: 'v2.0.0', assets: [{ name: 'dsh-workspace-mover-2.0.0.tgz', download_count: 11 }] }
+	]);
+	assert.equal(summary.visible, true);
+	const files = buildReleaseBadgeFiles({ total: summary.total, assets: summary.assets, updatedAt: '2026-09-10T00:00:00Z', visible: summary.visible });
+	const badge = JSON.parse(files['wsm-release-downloads.json'].content);
+	assert.equal(badge.label, 'Release downloads');
+	assert.equal(badge.message, '11');
+	assert.equal(badge.color, 'blue');
+	assert.equal(files['wsm-release-downloads.svg'], null);
+});
+
+test('hidden state deletes gist SVG and shields files so GitHub cannot render a broken alt-text link', () => {
+	const files = buildReleaseBadgeFiles({ total: 3, assets: [], updatedAt: '2026-09-10T00:00:00Z', visible: false });
+	assert.equal(files['wsm-release-downloads.json'], null);
+	assert.equal(files['wsm-release-downloads.svg'], null);
+	const data = JSON.parse(files['wsm-release-downloads-data.json'].content);
+	assert.equal(data.total, 3);
+	assert.equal(data.visible, false);
+});
+
+test('sanitizeGistPatchFiles skips deletes for files that are not on the gist', () => {
+	const patch = buildReleaseBadgeFiles({ total: 3, assets: [], updatedAt: '2026-09-10T00:00:00Z', visible: false });
+	const sanitized = sanitizeGistPatchFiles({ 'wsm-release-downloads-data.json': { content: '{}' } }, patch);
+	assert.deepEqual(Object.keys(sanitized).sort(), ['wsm-release-downloads-data.json']);
+	assert.equal(sanitized['wsm-release-downloads.json'], undefined);
+	assert.equal(sanitized['wsm-release-downloads.svg'], undefined);
+
+	const withExisting = sanitizeGistPatchFiles(
+		{
+			'wsm-release-downloads-data.json': { content: '{}' },
+			'wsm-release-downloads.json': { content: '{}' },
+			'wsm-clones-14d.json': { content: 'x' }
+		},
+		{ ...patch, 'wsm-clones-14d.json': null }
+	);
+	assert.equal(withExisting['wsm-release-downloads.json'], null);
+	assert.equal(withExisting['wsm-release-downloads.svg'], undefined);
+	assert.equal(withExisting['wsm-clones-14d.json'], null);
+	assert.equal(typeof withExisting['wsm-release-downloads-data.json'].content, 'string');
+});
+
+test('sanitizeGistPatchFiles turns empty content into a delete only when the file exists', () => {
+	const empty = sanitizeGistPatchFiles({}, { 'a.json': { content: '' } });
+	assert.deepEqual(empty, {});
+	const present = sanitizeGistPatchFiles({ 'a.json': { content: 'x' } }, { 'a.json': { content: '' } });
+	assert.deepEqual(present, { 'a.json': null });
+});
+
+test('README keeps an invisible marker below 10 and a shields graphic above 10', () => {
+	const source = [
+		'<p>',
+		'    <img alt="GitHub clones observed" src="https://img.shields.io/endpoint?url=https%3A%2F%2Fgist.githubusercontent.com%2FPianoPrince%2Fc14345658550a4a308570acfbaf9d170%2Fraw%2Fwsm-clones-total.json" style="height:20px; margin:0 2px;" />',
+		'    <img alt="Release downloads (shown after 10 downloads)" src="https://gist.githubusercontent.com/PianoPrince/c14345658550a4a308570acfbaf9d170/raw/wsm-release-downloads.svg" style="height:20px; margin:0 2px;" />',
+		'</p>'
+	].join('\n');
+	const hidden = applyReleaseBadgeToMarkdown(source, { visible: false, gistId });
+	assert.equal(hidden.includes('wsm-release-downloads.svg'), false);
+	assert.equal(hidden.includes('Release downloads (shown after 10 downloads)'), false);
+	assert.equal(hidden.includes('<img alt="Release downloads"'), false);
+	assert.equal(hidden.includes(RELEASE_BADGE_START), true);
+	assert.equal(hidden.includes(RELEASE_BADGE_END), true);
+	const shown = applyReleaseBadgeToMarkdown(hidden, { visible: true, gistId });
+	assert.equal(shown.includes('img.shields.io/endpoint?url='), true);
+	assert.equal(shown.includes('wsm-release-downloads.json'), true);
+	assert.equal(shown.includes('wsm-release-downloads.svg'), false);
+	assert.equal(shown.includes('<img alt="Release downloads"'), true);
+});
+
+test('extract-changelog accepts both current and historical heading styles', () => {
+        const script = fileURLToPath(new URL('../.github/scripts/extract-changelog.mjs', import.meta.url));
+        const current = execFileSync(process.execPath, [script, 'v2.0.1'], { encoding: 'utf8' });
+        const historical = execFileSync(process.execPath, [script, 'v1.4.2'], { encoding: 'utf8' });
+        assert.match(current, /Compatible with DeepSeek Harness/);
+        assert.match(historical, /GitHub Release tags now publish/);
+        assert.doesNotMatch(historical, /Compatible with DeepSeek Harness/);
+});

package/test/traffic-badge.test.mjs

@@ -1,80 +1,80 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { buildBadgeFiles, buildState, buildStructuredDaily, mergeHistory, normalizeClonesResponse, normalizePathsResponse, normalizeReferrersResponse, normalizeViewsResponse, parseHistory } from '../.github/scripts/traffic-badge-core.mjs';
-
-const snapshot = {
-	count: 12,
-	uniques: 7,
-	clones: [
-		{ timestamp: '2026-09-08T00:00:00Z', count: 5, uniques: 3 },
-		{ timestamp: '2026-09-09T00:00:00Z', count: 7, uniques: 4 }
-	]
-};
-
-test('traffic response uses GitHub clones[] rows and rejects the old days[] shape', () => {
-	const normalized = normalizeClonesResponse(snapshot);
-	assert.deepEqual(normalized.days, [
-		{ date: '2026-09-08', count: 5, uniques: 3 },
-		{ date: '2026-09-09', count: 7, uniques: 4 }
-	]);
-	assert.throws(() => normalizeClonesResponse({ count: 12, uniques: 7, days: snapshot.clones }), /no clones array/);
-});
-
-test('traffic normalizes views, referrers, and popular paths', () => {
-	assert.deepEqual(normalizeViewsResponse({ count: 9, uniques: 4, views: [{ timestamp: '2026-09-09T00:00:00Z', count: 9, uniques: 4 }] }).days, [
-		{ date: '2026-09-09', count: 9, uniques: 4 }
-	]);
-	assert.deepEqual(normalizeReferrersResponse([{ referrer: 'github.com', count: 3, uniques: 2 }]), [
-		{ referrer: 'github.com', count: 3, uniques: 2 }
-	]);
-	assert.deepEqual(normalizePathsResponse([{ path: '/README.md', title: 'README', count: 5, uniques: 3 }]), [
-		{ path: '/README.md', title: 'README', count: 5, uniques: 3 }
-	]);
-});
-
-test('history upsert replaces corrected dates without double counting', () => {
-	const old = parseHistory('{"date":"2026-09-08","count":4,"uniques":2}\n');
-	const merged = mergeHistory(old, [
-		{ date: '2026-09-08', count: 5, uniques: 3 },
-		{ date: '2026-09-09', count: 7, uniques: 4 }
-	]);
-	assert.deepEqual(merged, [
-		{ date: '2026-09-08', count: 5, uniques: 3 },
-		{ date: '2026-09-09', count: 7, uniques: 4 }
-	]);
-	const state = buildState({}, merged, normalizeClonesResponse(snapshot), '2026-09-10T00:00:00Z');
-	assert.equal(state.cumulativeClones, 12);
-	assert.equal(state.observedSince, '2026-09-08');
-});
-
-test('schema migration preserves the old value as a legacy estimate only', () => {
-	const state = buildState({ cumulative: 193 }, [], { ...normalizeClonesResponse(snapshot), days: [] }, '2026-09-10T00:00:00Z');
-	assert.equal(state.schemaVersion, 2);
-	assert.equal(state.cumulativeClones, 0);
-	assert.equal(state.legacyEstimate, 193);
-	assert.equal(state.lastWindow.count, 12);
-});
-
-test('badge exposes cumulative clones and cumulative uniques since the observation start', () => {
-	const state = buildState({}, parseHistory('{"date":"2026-09-08","count":5,"uniques":3}\n{"date":"2026-09-09","count":7,"uniques":4}\n'), normalizeClonesResponse(snapshot), '2026-09-10T00:00:00Z');
-	assert.equal(state.cumulativeUniques, 7);
-	const files = buildBadgeFiles(state);
-	const total = JSON.parse(files['wsm-clones-total.json'].content);
-	assert.equal(total.label, 'GitHub clones observed');
-	assert.equal(total.message, '12 since 2026-09-08 · 7 unique');
-	assert.equal(files['wsm-clones-14d.json'], undefined);
-});
-
-test('structured daily backfills JSONL-only early days without clobbering views', () => {
-	const existing = [{ date: '2026-09-09', clones: { date: '2026-09-09', count: 7, uniques: 4 }, views: { date: '2026-09-09', count: 2, uniques: 1 } }];
-	const historyRows = parseHistory('{"date":"2026-09-07","count":1,"uniques":1}\n{"date":"2026-09-08","count":5,"uniques":3}\n{"date":"2026-09-09","count":99,"uniques":99}\n');
-	const cloneDays = [{ date: '2026-09-09', count: 7, uniques: 4 }];
-	const viewDays = [{ date: '2026-09-09', count: 2, uniques: 1 }];
-	const daily = buildStructuredDaily(existing, historyRows, cloneDays, viewDays);
-	assert.deepEqual(daily.map((row) => row.date), ['2026-09-07', '2026-09-08', '2026-09-09']);
-	assert.deepEqual(daily[0].clones, { date: '2026-09-07', count: 1, uniques: 1 });
-	assert.equal(daily[0].views, undefined, 'JSONL 回填行没有 views 数据');
-	// JSONL 与快照冲突时快照优先：09-09 保持 7/4，且 views 不丢
-	assert.deepEqual(daily[2].clones, { date: '2026-09-09', count: 7, uniques: 4 });
-	assert.deepEqual(daily[2].views, { date: '2026-09-09', count: 2, uniques: 1 });
-});
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { buildBadgeFiles, buildState, buildStructuredDaily, mergeHistory, normalizeClonesResponse, normalizePathsResponse, normalizeReferrersResponse, normalizeViewsResponse, parseHistory } from '../.github/scripts/traffic-badge-core.mjs';
+
+const snapshot = {
+	count: 12,
+	uniques: 7,
+	clones: [
+		{ timestamp: '2026-09-08T00:00:00Z', count: 5, uniques: 3 },
+		{ timestamp: '2026-09-09T00:00:00Z', count: 7, uniques: 4 }
+	]
+};
+
+test('traffic response uses GitHub clones[] rows and rejects the old days[] shape', () => {
+	const normalized = normalizeClonesResponse(snapshot);
+	assert.deepEqual(normalized.days, [
+		{ date: '2026-09-08', count: 5, uniques: 3 },
+		{ date: '2026-09-09', count: 7, uniques: 4 }
+	]);
+	assert.throws(() => normalizeClonesResponse({ count: 12, uniques: 7, days: snapshot.clones }), /no clones array/);
+});
+
+test('traffic normalizes views, referrers, and popular paths', () => {
+	assert.deepEqual(normalizeViewsResponse({ count: 9, uniques: 4, views: [{ timestamp: '2026-09-09T00:00:00Z', count: 9, uniques: 4 }] }).days, [
+		{ date: '2026-09-09', count: 9, uniques: 4 }
+	]);
+	assert.deepEqual(normalizeReferrersResponse([{ referrer: 'github.com', count: 3, uniques: 2 }]), [
+		{ referrer: 'github.com', count: 3, uniques: 2 }
+	]);
+	assert.deepEqual(normalizePathsResponse([{ path: '/README.md', title: 'README', count: 5, uniques: 3 }]), [
+		{ path: '/README.md', title: 'README', count: 5, uniques: 3 }
+	]);
+});
+
+test('history upsert replaces corrected dates without double counting', () => {
+	const old = parseHistory('{"date":"2026-09-08","count":4,"uniques":2}\n');
+	const merged = mergeHistory(old, [
+		{ date: '2026-09-08', count: 5, uniques: 3 },
+		{ date: '2026-09-09', count: 7, uniques: 4 }
+	]);
+	assert.deepEqual(merged, [
+		{ date: '2026-09-08', count: 5, uniques: 3 },
+		{ date: '2026-09-09', count: 7, uniques: 4 }
+	]);
+	const state = buildState({}, merged, normalizeClonesResponse(snapshot), '2026-09-10T00:00:00Z');
+	assert.equal(state.cumulativeClones, 12);
+	assert.equal(state.observedSince, '2026-09-08');
+});
+
+test('schema migration preserves the old value as a legacy estimate only', () => {
+	const state = buildState({ cumulative: 193 }, [], { ...normalizeClonesResponse(snapshot), days: [] }, '2026-09-10T00:00:00Z');
+	assert.equal(state.schemaVersion, 2);
+	assert.equal(state.cumulativeClones, 0);
+	assert.equal(state.legacyEstimate, 193);
+	assert.equal(state.lastWindow.count, 12);
+});
+
+test('badge exposes cumulative clones and cumulative uniques since the observation start', () => {
+	const state = buildState({}, parseHistory('{"date":"2026-09-08","count":5,"uniques":3}\n{"date":"2026-09-09","count":7,"uniques":4}\n'), normalizeClonesResponse(snapshot), '2026-09-10T00:00:00Z');
+	assert.equal(state.cumulativeUniques, 7);
+	const files = buildBadgeFiles(state);
+	const total = JSON.parse(files['wsm-clones-total.json'].content);
+	assert.equal(total.label, 'GitHub clones observed');
+	assert.equal(total.message, '12 since 2026-09-08 · 7 unique');
+	assert.equal(files['wsm-clones-14d.json'], undefined);
+});
+
+test('structured daily backfills JSONL-only early days without clobbering views', () => {
+	const existing = [{ date: '2026-09-09', clones: { date: '2026-09-09', count: 7, uniques: 4 }, views: { date: '2026-09-09', count: 2, uniques: 1 } }];
+	const historyRows = parseHistory('{"date":"2026-09-07","count":1,"uniques":1}\n{"date":"2026-09-08","count":5,"uniques":3}\n{"date":"2026-09-09","count":99,"uniques":99}\n');
+	const cloneDays = [{ date: '2026-09-09', count: 7, uniques: 4 }];
+	const viewDays = [{ date: '2026-09-09', count: 2, uniques: 1 }];
+	const daily = buildStructuredDaily(existing, historyRows, cloneDays, viewDays);
+	assert.deepEqual(daily.map((row) => row.date), ['2026-09-07', '2026-09-08', '2026-09-09']);
+	assert.deepEqual(daily[0].clones, { date: '2026-09-07', count: 1, uniques: 1 });
+	assert.equal(daily[0].views, undefined, 'JSONL 回填行没有 views 数据');
+	// JSONL 与快照冲突时快照优先：09-09 保持 7/4，且 views 不丢
+	assert.deepEqual(daily[2].clones, { date: '2026-09-09', count: 7, uniques: 4 });
+	assert.deepEqual(daily[2].views, { date: '2026-09-09', count: 2, uniques: 1 });
+});