@cspeach/cli 0.6.4 → 0.6.5

package/dist/session/__tests__/time-ago.test.js

@@ -1,53 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { formatTimeAgo } from '../time-ago.js';
-describe('formatTimeAgo', () => {
-    const NOW = new Date('2026-05-09T20:00:00Z');
-    it('seconds', () => {
-        expect(formatTimeAgo('2026-05-09T19:59:30Z', NOW)).toBe('30s ago');
-    });
-    it('minutes', () => {
-        expect(formatTimeAgo('2026-05-09T19:55:00Z', NOW)).toBe('5m ago');
-    });
-    it('hours', () => {
-        expect(formatTimeAgo('2026-05-09T17:00:00Z', NOW)).toBe('3h ago');
-    });
-    it('yesterday at exactly 24h', () => {
-        expect(formatTimeAgo('2026-05-08T20:00:00Z', NOW)).toBe('yesterday');
-    });
-    it('yesterday at 47h', () => {
-        expect(formatTimeAgo('2026-05-07T21:00:00Z', NOW)).toBe('yesterday');
-    });
-    it('multiple days', () => {
-        expect(formatTimeAgo('2026-05-06T20:00:00Z', NOW)).toBe('3d ago');
-    });
-    it('weeks', () => {
-        expect(formatTimeAgo('2026-04-25T20:00:00Z', NOW)).toBe('2w ago');
-    });
-    it('months', () => {
-        // Feb 9 → May 9 ≈ 89 days, floor(89/30) = 2
-        expect(formatTimeAgo('2026-02-09T20:00:00Z', NOW)).toBe('2mo ago');
-    });
-    it('years', () => {
-        expect(formatTimeAgo('2024-05-09T20:00:00Z', NOW)).toBe('2y ago');
-    });
-    it('handles invalid date strings', () => {
-        expect(formatTimeAgo('not-a-date', NOW)).toBe('?');
-    });
-    it('clamps future timestamps to 0s', () => {
-        expect(formatTimeAgo('2030-01-01T00:00:00Z', NOW)).toBe('0s ago');
-    });
-    it('produces strings under 12 chars', () => {
-        const samples = [
-            formatTimeAgo('2026-05-09T19:59:30Z', NOW),
-            formatTimeAgo('2026-05-09T17:00:00Z', NOW),
-            formatTimeAgo('2026-05-08T20:00:00Z', NOW),
-            formatTimeAgo('2026-05-06T20:00:00Z', NOW),
-            formatTimeAgo('2026-04-25T20:00:00Z', NOW),
-            formatTimeAgo('2026-02-09T20:00:00Z', NOW),
-            formatTimeAgo('2024-05-09T20:00:00Z', NOW),
-        ];
-        for (const s of samples) {
-            expect(s.length).toBeLessThan(12);
-        }
-    });
-});

package/dist/skills/__tests__/canonical.test.js

@@ -1,20 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { canonicalise } from '../canonical.js';
-describe('canonicalise', () => {
-    it('sorts keys alphabetically at every level', () => {
-        expect(canonicalise({ b: 1, a: 2 })).toBe('{"a":2,"b":1}');
-        expect(canonicalise({ z: { b: 1, a: 2 }, y: [3, 1] }))
-            .toBe('{"y":[3,1],"z":{"a":2,"b":1}}');
-    });
-    it('matches golden vector (proxy + CLI must produce identical bytes)', () => {
-        const input = {
-            version: '1.0.0',
-            subkey_id: 'subkey-2026q2',
-            published_at: '2026-04-23T00:00:00Z',
-            skills: [{ name: 'abap-generate', sha256: 'a'.repeat(64), updated_at: '2026-04-23T00:00:00Z', body_url: 'https://manifest.cspeach.dev/v1/skills-public/abap-generate' }],
-        };
-        // GOLDEN VECTOR — if this changes, update the proxy side in the same PR.
-        const expected = '{"published_at":"2026-04-23T00:00:00Z","skills":[{"body_url":"https://manifest.cspeach.dev/v1/skills-public/abap-generate","name":"abap-generate","sha256":"' + 'a'.repeat(64) + '","updated_at":"2026-04-23T00:00:00Z"}],"subkey_id":"subkey-2026q2","version":"1.0.0"}';
-        expect(canonicalise(input)).toBe(expected);
-    });
-});

package/dist/skills/__tests__/manifest-client.test.js

@@ -1,88 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-const mockFetch = vi.fn();
-vi.stubGlobal('fetch', mockFetch);
-// Mock signing-public-key module so tests run identically regardless of prebuild state.
-// ed25519 public key: exactly 32 bytes → 44 base64 chars incl. padding.
-vi.mock('../signing-public-key.js', () => ({
-    MANIFEST_PUBLIC_KEYS: ['AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA='],
-}));
-// 64 zero bytes base64-encoded = 86 chars + '==' padding = 88 chars.
-const INVALID_BUT_WELL_FORMED_SIGNATURE = 'A'.repeat(86) + '==';
-const MANIFEST_URL = 'https://manifest.cspeach.dev/v1.json';
-describe('ManifestClient', () => {
-    beforeEach(() => { mockFetch.mockReset(); });
-    it('fetches the manifest from the configured URL', async () => {
-        const manifest = {
-            version: '1.0.0',
-            subkey_id: 'subkey-2026q2',
-            published_at: '2026-04-23T00:00:00Z',
-            skills: [],
-            signature: 'not-verified-in-this-test',
-        };
-        mockFetch.mockResolvedValueOnce({ ok: true, json: async () => manifest });
-        const { ManifestClient } = await import('../manifest-client.js');
-        const c = new ManifestClient(MANIFEST_URL);
-        const got = await c.fetchManifest();
-        expect(got.version).toBe('1.0.0');
-        expect(mockFetch).toHaveBeenCalledWith(MANIFEST_URL, expect.any(Object));
-    });
-    it('rejects a manifest with invalid signature', async () => {
-        const manifest = {
-            version: '1.0.0',
-            subkey_id: 'subkey-2026q2',
-            published_at: '2026-04-23T00:00:00Z',
-            skills: [],
-            signature: INVALID_BUT_WELL_FORMED_SIGNATURE,
-        };
-        mockFetch.mockResolvedValueOnce({ ok: true, json: async () => manifest });
-        const { ManifestClient } = await import('../manifest-client.js');
-        const c = new ManifestClient(MANIFEST_URL);
-        await expect(c.fetchAndVerifyManifest()).rejects.toThrow(/manifest signature invalid/i);
-    });
-    it('surfaces a friendly error when manifest is not yet published (503)', async () => {
-        mockFetch.mockResolvedValueOnce({
-            ok: false,
-            status: 503,
-            json: async () => ({ error: 'manifest not yet published' }),
-        });
-        const { ManifestClient } = await import('../manifest-client.js');
-        const c = new ManifestClient(MANIFEST_URL);
-        await expect(c.fetchManifest()).rejects.toThrow(/not yet published|HTTP 503/i);
-    });
-    it('surfaces a friendly error when manifest fetch times out / network is down', async () => {
-        mockFetch.mockRejectedValueOnce(new Error('fetch failed: ECONNREFUSED'));
-        const { ManifestClient } = await import('../manifest-client.js');
-        const c = new ManifestClient(MANIFEST_URL);
-        await expect(c.fetchManifest()).rejects.toThrow(/ECONNREFUSED|fetch failed/);
-    });
-    it('verifies per-skill sha256 when body fetched', async () => {
-        mockFetch.mockResolvedValueOnce({ ok: true, json: async () => ({
-                body: 'hello',
-                sha256: '2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824',
-            }) });
-        const { ManifestClient } = await import('../manifest-client.js');
-        const c = new ManifestClient(MANIFEST_URL);
-        const body = await c.fetchSkillBody('abap-generate', 'https://manifest.cspeach.dev/v1/skills-public/abap-generate', { expectedSha256: '2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824' });
-        expect(body.body).toBe('hello');
-    });
-    it('throws if the recomputed body sha256 does not match the manifest-anchored value (tampered body)', async () => {
-        // The body is 'tampered-content', expected is the sha of 'hello'. The
-        // check is over the recomputed hash of the delivered bytes — the
-        // server-claimed sha field is untrusted and not consulted.
-        mockFetch.mockResolvedValueOnce({ ok: true, json: async () => ({
-                body: 'tampered-content',
-                // Include a *correct* server-claimed sha for the tampered body to
-                // confirm the recomputed check still rejects when only the body is
-                // wrong (I6 — server-claimed sha carries no security weight).
-                sha256: '772d54f10d1ce3976a92c59cf4b2d3ec42ed2e9f2ff6e7b9efce0bf06cfa9efe',
-            }) });
-        const { ManifestClient } = await import('../manifest-client.js');
-        const c = new ManifestClient(MANIFEST_URL);
-        await expect(c.fetchSkillBody('abap-generate', 'https://manifest.cspeach.dev/v1/skills-public/abap-generate', { expectedSha256: '2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824' })).rejects.toThrow(/sha256/i);
-    });
-    it('accepts a manifest signed by the previous-rollover key (dual-key overlap)', async () => {
-        // This test is skipped in CI unless both current + previous keys are loaded.
-        // Documents the 30-day rollover behaviour per spec §13.1.
-        // Full end-to-end covered by Task A.16 Step 6.
-    });
-});

package/dist/skills/__tests__/promotion-dispatch.test.js

@@ -1,28 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { parseFromFlag } from '../promotion-dispatch.js';
-describe('parseFromFlag', () => {
-    it('returns fromPath when --from @file is present', () => {
-        expect(parseFromFlag('--from @./customer-aging-spec-gap-a1b2-v3.cspeach.json'))
-            .toEqual({ fromPath: './customer-aging-spec-gap-a1b2-v3.cspeach.json', rest: '' });
-    });
-    it('strips --from from the rest of the args', () => {
-        expect(parseFromFlag('developer-profile: senior --from @file.json includes: tests'))
-            .toEqual({ fromPath: 'file.json', rest: 'developer-profile: senior  includes: tests' });
-    });
-    it('returns null fromPath when flag is absent', () => {
-        expect(parseFromFlag('developer-profile: senior'))
-            .toEqual({ fromPath: null, rest: 'developer-profile: senior' });
-    });
-    it('handles --from @"path with spaces.json"', () => {
-        expect(parseFromFlag('--from @"some path with spaces.cspeach.json"'))
-            .toEqual({ fromPath: 'some path with spaces.cspeach.json', rest: '' });
-    });
-    it('returns null when --from has no file argument', () => {
-        expect(parseFromFlag('--from'))
-            .toEqual({ fromPath: null, rest: '--from' });
-    });
-    it('handles paths containing @ (email-like names)', () => {
-        expect(parseFromFlag('--from @hello@bar.cspeach.json'))
-            .toEqual({ fromPath: 'hello@bar.cspeach.json', rest: '' });
-    });
-});

package/dist/skills/__tests__/source-managed.test.js

@@ -1,60 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-const mockFetch = vi.fn();
-vi.stubGlobal('fetch', mockFetch);
-const cfg = {
-    proxy_url: 'https://api.cspeach.dev/',
-    default_model: 'claude-opus-4-7',
-    effort: 'medium',
-    telemetry: 'minimal',
-    write_mode: 'approval-gated',
-    llm: { mode: 'managed' },
-    sap: {},
-    classifier: { safe_mode: false },
-    ui: { rendering: 'classic' },
-};
-describe('createManagedSkillSource', () => {
-    beforeEach(() => { mockFetch.mockReset(); });
-    it('parses the JSON shape returned by cspeach-proxy /v1/skills/:name', async () => {
-        mockFetch.mockResolvedValueOnce({
-            ok: true,
-            json: async () => ({
-                name: 'abap-generate',
-                body: '# skill body',
-                sha256: 'a'.repeat(64),
-                signature: 'sig-b64',
-                signedAt: '2026-04-23T00:00:00Z',
-                subkey_id: 'subkey-2026q2',
-                required_tools: ['sap_create_object'],
-                min_cli_version: '0.3.0',
-            }),
-        });
-        const { createManagedSkillSource } = await import('../source-managed.js');
-        const src = createManagedSkillSource(cfg, async () => 'bearer-token');
-        const body = await src.getSkillBody('abap-generate');
-        expect(body).toEqual({
-            name: 'abap-generate',
-            body: '# skill body',
-            sha256: 'a'.repeat(64),
-            signature: 'sig-b64',
-            signedAt: '2026-04-23T00:00:00Z',
-        });
-        // Trailing slash on proxy_url must be collapsed; skill name must be URL-encoded.
-        expect(mockFetch).toHaveBeenCalledWith('https://api.cspeach.dev/v1/skills/abap-generate', expect.objectContaining({ headers: { Authorization: 'Bearer bearer-token' } }));
-    });
-    it('throws with HTTP status on non-2xx', async () => {
-        mockFetch.mockResolvedValueOnce({ ok: false, status: 404 });
-        const { createManagedSkillSource } = await import('../source-managed.js');
-        const src = createManagedSkillSource(cfg, async () => 'bearer-token');
-        await expect(src.getSkillBody('missing')).rejects.toThrow(/HTTP 404/);
-    });
-    it('lists skills from /v1/skills', async () => {
-        mockFetch.mockResolvedValueOnce({
-            ok: true,
-            json: async () => ({ skills: [{ name: 'abap-generate' }, { name: 'abap-explain' }] }),
-        });
-        const { createManagedSkillSource } = await import('../source-managed.js');
-        const src = createManagedSkillSource(cfg, async () => 'bearer-token');
-        const names = await src.listAvailableSkills();
-        expect(names).toEqual(['abap-generate', 'abap-explain']);
-    });
-});

package/dist/tools/__tests__/_background-shared.test.js

@@ -1,69 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { registerBackground, recordEvent, consumeEvents, getBackground, __resetRegistryForTests, __isExitHandlerInstalledForTests, installExitHandler, MAX_EVENTS_PER_BG, } from '../subagent/_background-shared.js';
-beforeEach(() => { __resetRegistryForTests(); });
-describe('_background-shared registry', () => {
-    it('registerBackground returns a new entry indexable by bg_id', () => {
-        const entry = registerBackground({
-            bg_id: 'bg-test-1',
-            command: 'node',
-            argv: ['-e', 'console.log(1)'],
-            child: { kill: () => true, pid: 12345 },
-        });
-        expect(entry.bg_id).toBe('bg-test-1');
-        expect(entry.command).toBe('node');
-        expect(entry.closed).toBe(false);
-        expect(getBackground('bg-test-1')).toBe(entry);
-    });
-    it('recordEvent appends to the per-bg ring buffer; consumeEvents drains in FIFO order', () => {
-        registerBackground({ bg_id: 'bg-2', command: 'node', argv: [], child: { kill: () => true, pid: 1 } });
-        recordEvent('bg-2', { kind: 'stdout', text: 'first', ts: 1 });
-        recordEvent('bg-2', { kind: 'stdout', text: 'second', ts: 2 });
-        recordEvent('bg-2', { kind: 'stderr', text: 'err1', ts: 3 });
-        const r1 = consumeEvents('bg-2', 2);
-        expect(r1.events.map((e) => e.text)).toEqual(['first', 'second']);
-        expect(r1.dropped).toBe(0);
-        const r2 = consumeEvents('bg-2', 10);
-        expect(r2.events.map((e) => e.text)).toEqual(['err1']);
-        expect(r2.dropped).toBe(0);
-        const r3 = consumeEvents('bg-2', 10);
-        expect(r3.events).toHaveLength(0);
-        expect(r3.dropped).toBe(0);
-    });
-    it('FIFO eviction kicks in at MAX_EVENTS_PER_BG and surfaces dropped counter on next consume', () => {
-        registerBackground({ bg_id: 'bg-evict', command: 'node', argv: [], child: { kill: () => true, pid: 1 } });
-        for (let i = 0; i < MAX_EVENTS_PER_BG + 50; i++) {
-            recordEvent('bg-evict', { kind: 'stdout', text: `line ${i}`, ts: i });
-        }
-        const r = consumeEvents('bg-evict', MAX_EVENTS_PER_BG);
-        expect(r.events.length).toBe(MAX_EVENTS_PER_BG);
-        expect(r.dropped).toBe(50);
-        expect(r.events[0].text).toBe('line 50'); // oldest 50 evicted
-        // Subsequent consume reports 0 dropped — counter resets on read.
-        const r2 = consumeEvents('bg-evict', 10);
-        expect(r2.dropped).toBe(0);
-    });
-    it('consumeEvents on a missing bg_id returns null (caller surfaces error envelope)', () => {
-        expect(consumeEvents('does-not-exist', 10)).toBeNull();
-    });
-    it('recordEvent on a missing bg_id is a silent no-op (race: child wrote after monitor cleared)', () => {
-        expect(() => recordEvent('does-not-exist', { kind: 'stdout', text: 'x', ts: 1 })).not.toThrow();
-    });
-    it('installExitHandler is idempotent (calling twice does NOT register two listeners)', () => {
-        // Ordering note: this test must be the first-or-only caller of installExitHandler()
-        // in this file. __resetRegistryForTests() does NOT reset exitHandlerInstalled
-        // (handler is process-lifetime-scoped). If a future test in this file installs
-        // the handler before this one, the line-below assertion will fail.
-        expect(__isExitHandlerInstalledForTests()).toBe(false);
-        installExitHandler();
-        expect(__isExitHandlerInstalledForTests()).toBe(true);
-        installExitHandler(); // second call must be a no-op
-        expect(__isExitHandlerInstalledForTests()).toBe(true);
-    });
-    it('recordEvent marks the entry closed on `exit` kind', () => {
-        registerBackground({ bg_id: 'bg-close', command: 'node', argv: [], child: { kill: () => true, pid: 1 } });
-        expect(getBackground('bg-close').closed).toBe(false);
-        recordEvent('bg-close', { kind: 'exit', text: 'code=0', ts: 1, exitCode: 0, signal: null });
-        expect(getBackground('bg-close').closed).toBe(true);
-        expect(getBackground('bg-close').exitCode).toBe(0);
-    });
-});

package/dist/tools/__tests__/_command-shared.test.js

@@ -1,59 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { DEFAULT_SAFELIST, loadSafelist, buildSafeEnv, resolveExecutable, validateArgv, rejectPathSeparator, MAX_ARGS, MAX_ARG_BYTES, KILL_GRACE_MS, } from '../_command-shared.js';
-describe('_command-shared', () => {
-    it('DEFAULT_SAFELIST contains npm/pnpm/ui5/cds/git/abaplint/node', () => {
-        for (const cmd of ['npm', 'pnpm', 'ui5', 'cds', 'git', 'abaplint', 'node']) {
-            expect(DEFAULT_SAFELIST.has(cmd)).toBe(true);
-        }
-    });
-    it('loadSafelist returns at least the defaults even when config is empty', async () => {
-        const set = await loadSafelist();
-        expect(set.has('npm')).toBe(true);
-        expect(set.has('git')).toBe(true);
-    });
-    it('buildSafeEnv strips CSPEACH_*, ANTHROPIC_*, SAP_* and passes PATH through', () => {
-        const orig = process.env.PATH;
-        process.env.CSPEACH_TOKEN_TEST = 'leak';
-        process.env.ANTHROPIC_API_KEY_TEST = 'leak';
-        process.env.SAP_PASSWORD_TEST = 'leak';
-        try {
-            const env = buildSafeEnv();
-            expect(env.PATH ?? env.Path).toBe(orig);
-            expect(env.CSPEACH_TOKEN_TEST).toBeUndefined();
-            expect(env.ANTHROPIC_API_KEY_TEST).toBeUndefined();
-            expect(env.SAP_PASSWORD_TEST).toBeUndefined();
-        }
-        finally {
-            delete process.env.CSPEACH_TOKEN_TEST;
-            delete process.env.ANTHROPIC_API_KEY_TEST;
-            delete process.env.SAP_PASSWORD_TEST;
-        }
-    });
-    it('resolveExecutable finds `node` on PATH (every CSPeach dev box has node)', async () => {
-        const resolved = await resolveExecutable('node');
-        expect(resolved).not.toBeNull();
-        expect(resolved).toMatch(/node(\.exe|\.cmd)?$/i);
-    });
-    it('validateArgv rejects > MAX_ARGS', () => {
-        const tooMany = Array.from({ length: MAX_ARGS + 1 }, () => 'x');
-        const err = validateArgv(tooMany);
-        expect(err).not.toBeNull();
-        expect(err).toMatch(/too many args/i);
-    });
-    it('validateArgv rejects an oversize element (> MAX_ARG_BYTES)', () => {
-        const argv = ['ok', 'x'.repeat(MAX_ARG_BYTES + 1)];
-        const err = validateArgv(argv);
-        expect(err).not.toBeNull();
-        expect(err).toMatch(/exceeds.*max length/i);
-    });
-    it('rejectPathSeparator rejects absolute and slash-bearing names', () => {
-        expect(rejectPathSeparator('/bin/sh')).toMatch(/separators|absolute/i);
-        expect(rejectPathSeparator('C:\\Windows\\System32\\cmd.exe')).toMatch(/separators|absolute/i);
-        expect(rejectPathSeparator('node/foo')).toMatch(/separators|absolute/i);
-        expect(rejectPathSeparator('node')).toBeNull();
-    });
-    it('exports KILL_GRACE_MS for downstream lifecycle managers', () => {
-        expect(typeof KILL_GRACE_MS).toBe('number');
-        expect(KILL_GRACE_MS).toBeGreaterThan(0);
-    });
-});

package/dist/tools/__tests__/_filesystem-shared.test.js

@@ -1,42 +0,0 @@
-// cspeach-cli/src/tools/__tests__/_filesystem-shared.test.ts
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { promises as fs } from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { resolveSafePath, PathOutsideRootError } from '../_filesystem-shared.js';
-let root;
-beforeEach(async () => { root = await fs.mkdtemp(path.join(os.tmpdir(), 'cspeach-fsshared-')); });
-afterEach(async () => { await fs.rm(root, { recursive: true, force: true }); });
-describe('resolveSafePath', () => {
-    it('returns the absolute path when input is inside root', () => {
-        const result = resolveSafePath(root, 'src/foo.ts');
-        expect(result).toBe(path.resolve(root, 'src/foo.ts'));
-    });
-    it('throws PathOutsideRootError on a `..` traversal that escapes root', () => {
-        expect(() => resolveSafePath(root, '../../etc/passwd')).toThrow(PathOutsideRootError);
-    });
-    it('throws on absolute paths outside root', () => {
-        expect(() => resolveSafePath(root, 'C:\\Windows\\System32\\drivers\\etc\\hosts')).toThrow(PathOutsideRootError);
-    });
-    it('allows absolute paths that resolve INSIDE root', () => {
-        const inside = path.join(root, 'inside.ts');
-        const result = resolveSafePath(root, inside);
-        expect(result).toBe(path.resolve(inside));
-    });
-    it('rejects null-byte paths (hostile input)', () => {
-        expect(() => resolveSafePath(root, 'foo\0bar')).toThrow(PathOutsideRootError);
-    });
-    it('treats empty string as root (resolves to root, no throw)', () => {
-        const result = resolveSafePath(root, '');
-        expect(result).toBe(path.resolve(root));
-    });
-    it('treats "." as root (resolves to root, no throw)', () => {
-        const result = resolveSafePath(root, '.');
-        expect(result).toBe(path.resolve(root));
-    });
-    it('allows paths that touch `..` but resolve cleanly inside root', () => {
-        // 'subdir/..' resolves to root itself — allowed.
-        const result = resolveSafePath(root, 'subdir/..');
-        expect(result).toBe(path.resolve(root));
-    });
-});

package/dist/tools/__tests__/_flag.test.js

@@ -1,66 +0,0 @@
-// cspeach-cli/src/tools/__tests__/_flag.test.ts
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { isToolFlagOn, TOOL_FLAG_PREFIX, __resetFlagWarningsForTests } from '../_flag.js';
-const FLAG = `${TOOL_FLAG_PREFIX}FILE_READ`;
-beforeEach(() => { delete process.env[FLAG]; });
-afterEach(() => { delete process.env[FLAG]; });
-describe('isToolFlagOn', () => {
-    it('returns false when env var is unset', () => {
-        expect(isToolFlagOn('file_read')).toBe(false);
-    });
-    it('returns true only for exact value "on"', () => {
-        process.env[FLAG] = 'on';
-        expect(isToolFlagOn('file_read')).toBe(true);
-    });
-    it('rejects "ON", "true", "1", etc.', () => {
-        for (const v of ['ON', 'On', 'true', '1', 'yes', '']) {
-            process.env[FLAG] = v;
-            expect(isToolFlagOn('file_read')).toBe(false);
-        }
-    });
-    it('uppercases tool name correctly (file_read → CSPEACH_TOOL_FILE_READ)', () => {
-        process.env[FLAG] = 'on';
-        expect(isToolFlagOn('file_read')).toBe(true);
-        expect(isToolFlagOn('FILE_READ')).toBe(true); // case-insensitive on input
-    });
-});
-describe('isToolFlagOn — whitespace + misconfig handling', () => {
-    beforeEach(() => { __resetFlagWarningsForTests(); });
-    it('treats " on " (with whitespace) as on', () => {
-        process.env[FLAG] = ' on ';
-        expect(isToolFlagOn('file_read')).toBe(true);
-    });
-    it('warns to stderr ONCE when flag is set but not "on"', () => {
-        process.env[FLAG] = 'true';
-        const writes = [];
-        const spy = vi.spyOn(process.stderr, 'write').mockImplementation((c) => {
-            writes.push(typeof c === 'string' ? c : c.toString());
-            return true;
-        });
-        try {
-            expect(isToolFlagOn('file_read')).toBe(false);
-            expect(isToolFlagOn('file_read')).toBe(false); // second call
-            const warnLines = writes.filter((s) => s.includes(FLAG));
-            expect(warnLines).toHaveLength(1); // one-shot
-            expect(warnLines[0]).toContain('did you mean');
-        }
-        finally {
-            spy.mockRestore();
-        }
-    });
-    it('does NOT warn when flag is unset', () => {
-        delete process.env[FLAG];
-        const writes = [];
-        const spy = vi.spyOn(process.stderr, 'write').mockImplementation((c) => {
-            writes.push(typeof c === 'string' ? c : c.toString());
-            return true;
-        });
-        try {
-            expect(isToolFlagOn('file_read')).toBe(false);
-            expect(writes.filter((s) => s.includes(FLAG))).toHaveLength(0);
-        }
-        finally {
-            spy.mockRestore();
-        }
-    });
-});

package/dist/tools/__tests__/_helpers.js

@@ -1,17 +0,0 @@
-/**
- * Minimal ToolContext for filesystem-tool unit tests. Tests typically
- * only need `cwd` populated; the rest get defaulted to safe stubs.
- *
- * Phase 3 helper — extend the shape here as new filesystem tools
- * need new ctx fields. Single source of truth prevents drift across
- * 5+ test files.
- */
-export function makeCtx(cwd, overrides = {}) {
-    return {
-        adt: {},
-        sapAlias: 'TEST',
-        session: {},
-        cwd,
-        ...overrides,
-    };
-}