@crouton-kit/crouter 0.3.11 → 0.3.12

package/dist/core/__tests__/job.test.js

@@ -1,310 +0,0 @@
-// Tests for the job subtree (monitoring) and agent/mode spawn leaves argv
-// migration. Exercises parseArgv against each leaf's param schema directly —
-// no subprocess, no tmux, no filesystem side-effects from the handler.
-//
-// Run with: node --import tsx/esm --test src/core/__tests__/job.test.ts
-import { test, describe } from 'node:test';
-import assert from 'node:assert/strict';
-import { parseArgv } from '../command.js';
-// ---------------------------------------------------------------------------
-// Param schemas extracted from each leaf (mirrors job.ts exactly)
-// ---------------------------------------------------------------------------
-const startPromptParams = [
-    { kind: 'stdin', name: 'prompt', required: true, constraint: '' },
-    { kind: 'flag', name: 'cwd', type: 'path', required: false, constraint: '' },
-];
-const startForkParams = [
-    { kind: 'flag', name: 'cwd', type: 'path', required: false, constraint: '' },
-];
-const startPlannerParams = [
-    { kind: 'positional', name: 'spec_path', type: 'path', required: true, constraint: '' },
-    { kind: 'flag', name: 'cwd', type: 'path', required: false, constraint: '' },
-];
-const startImplementerParams = [
-    { kind: 'positional', name: 'plan_path', type: 'path', required: true, constraint: '' },
-    { kind: 'flag', name: 'cwd', type: 'path', required: false, constraint: '' },
-];
-const startReviewerParams = [
-    { kind: 'positional', name: 'artifact_path', type: 'path', required: true, constraint: '' },
-    { kind: 'flag', name: 'kind', type: 'enum', choices: ['plan', 'spec'], required: true, constraint: '' },
-    { kind: 'flag', name: 'spec-path', type: 'path', required: false, constraint: '' },
-    { kind: 'flag', name: 'cwd', type: 'path', required: false, constraint: '' },
-];
-const readListParams = [
-    { kind: 'flag', name: 'limit', type: 'int', required: false, default: 20, constraint: '' },
-    { kind: 'flag', name: 'cursor', type: 'string', required: false, constraint: '' },
-];
-const readStatusParams = [
-    { kind: 'positional', name: 'job_id', type: 'string', required: true, constraint: '' },
-];
-const readResultParams = [
-    { kind: 'positional', name: 'job_id', type: 'string', required: true, constraint: '' },
-    { kind: 'flag', name: 'wait', type: 'bool', required: false, constraint: '' },
-];
-const readLogsParams = [
-    { kind: 'positional', name: 'job_id', type: 'string', required: true, constraint: '' },
-    { kind: 'flag', name: 'since', type: 'string', required: false, constraint: '' },
-    { kind: 'flag', name: 'until', type: 'string', required: false, constraint: '' },
-    { kind: 'flag', name: 'level', type: 'enum', choices: ['debug', 'info', 'warn', 'error'], required: false, default: 'info', constraint: '' },
-    { kind: 'flag', name: 'follow', type: 'bool', required: false, constraint: '' },
-];
-// NOTE: the real leaf also declares a `stdin` param for `body`. We omit it
-// from the test schema because parseArgv reads stdin to EOF whenever a stdin
-// param is declared — and under `node --test`, stdin is piped with no EOF, so
-// the call hangs forever. The body-required-on-status=done check lives in the
-// leaf's `run` handler, not in parseArgv, so the schema tests below cover
-// everything parseArgv can see without needing stdin.
-const submitParams = [
-    { kind: 'positional', name: 'job_id', type: 'string', required: true, constraint: '' },
-    { kind: 'flag', name: 'status', type: 'enum', choices: ['done', 'failed'], required: false, default: 'done', constraint: '' },
-    { kind: 'flag', name: 'reason', type: 'string', required: false, constraint: '' },
-    { kind: 'flag', name: 'kill-pane', type: 'bool', required: false, constraint: '' },
-];
-const cancelParams = [
-    { kind: 'positional', name: 'job_id', type: 'string', required: true, constraint: '' },
-];
-const failParams = [
-    { kind: 'positional', name: 'job_id', type: 'string', required: true, constraint: '' },
-];
-// ---------------------------------------------------------------------------
-// agent new (formerly job start prompt)
-// ---------------------------------------------------------------------------
-describe('agent new', () => {
-    // stdin is handled by readStdinRaw() which requires actual stdin — we only
-    // test the non-stdin flag parsing here.
-    test('--cwd flag parsed as string', async () => {
-        // stdin param will be read but we can't pipe here — skip stdin assertion,
-        // test that cwd parses correctly alongside other tokens.
-        // We test the flag-only shape: no stdin params in isolation.
-        const flagOnlyParams = [
-            { kind: 'flag', name: 'cwd', type: 'path', required: false, constraint: '' },
-        ];
-        const result = await parseArgv(flagOnlyParams, ['--cwd', '/tmp/mydir']);
-        assert.equal(result['cwd'], '/tmp/mydir');
-    });
-    test('cwd absent → undefined', async () => {
-        const flagOnlyParams = [
-            { kind: 'flag', name: 'cwd', type: 'path', required: false, constraint: '' },
-        ];
-        const result = await parseArgv(flagOnlyParams, []);
-        assert.equal(result['cwd'], undefined);
-    });
-});
-// ---------------------------------------------------------------------------
-// agent fork (formerly job start fork)
-// ---------------------------------------------------------------------------
-describe('agent fork', () => {
-    test('no args parses cleanly', async () => {
-        const result = await parseArgv(startForkParams, []);
-        assert.equal(result['cwd'], undefined);
-    });
-    test('--cwd parsed', async () => {
-        const result = await parseArgv(startForkParams, ['--cwd', '/workspace']);
-        assert.equal(result['cwd'], '/workspace');
-    });
-    test('unknown positional rejected', async () => {
-        await assert.rejects(() => parseArgv(startForkParams, ['extra-pos']), (err) => { assert.match(err.message, /takes no positional/); return true; });
-    });
-});
-// ---------------------------------------------------------------------------
-// mode planner (formerly job start planner)
-// ---------------------------------------------------------------------------
-describe('mode planner', () => {
-    test('positional spec_path required', async () => {
-        await assert.rejects(() => parseArgv(startPlannerParams, []), (err) => { assert.match(err.message, /required parameter is missing/); return true; });
-    });
-    test('positional parsed as spec_path (camelCase: specPath? no — underscore stays as-is)', async () => {
-        const result = await parseArgv(startPlannerParams, ['/tmp/spec.md']);
-        // flagNameToKey converts kebab to camel; underscores are unaffected
-        assert.equal(result['spec_path'], '/tmp/spec.md');
-    });
-    test('--cwd optional', async () => {
-        const result = await parseArgv(startPlannerParams, ['/tmp/spec.md', '--cwd', '/src']);
-        assert.equal(result['cwd'], '/src');
-        assert.equal(result['spec_path'], '/tmp/spec.md');
-    });
-});
-// ---------------------------------------------------------------------------
-// mode implementer (formerly job start implementer)
-// ---------------------------------------------------------------------------
-describe('mode implementer', () => {
-    test('positional plan_path required', async () => {
-        await assert.rejects(() => parseArgv(startImplementerParams, []), (err) => { assert.match(err.message, /required parameter is missing/); return true; });
-    });
-    test('positional parsed', async () => {
-        const result = await parseArgv(startImplementerParams, ['/tmp/plan.md']);
-        assert.equal(result['plan_path'], '/tmp/plan.md');
-    });
-});
-// ---------------------------------------------------------------------------
-// mode reviewer (formerly job start reviewer)
-// ---------------------------------------------------------------------------
-describe('mode reviewer', () => {
-    test('positional + --kind required', async () => {
-        await assert.rejects(() => parseArgv(startReviewerParams, ['/tmp/artifact.md']), (err) => { assert.match(err.message, /required parameter is missing/); return true; });
-    });
-    test('valid kind: plan', async () => {
-        const result = await parseArgv(startReviewerParams, ['/tmp/artifact.md', '--kind', 'plan']);
-        assert.equal(result['artifact_path'], '/tmp/artifact.md');
-        assert.equal(result['kind'], 'plan');
-    });
-    test('valid kind: spec', async () => {
-        const result = await parseArgv(startReviewerParams, ['/tmp/artifact.md', '--kind', 'spec']);
-        assert.equal(result['kind'], 'spec');
-    });
-    test('invalid kind throws invalid_type', async () => {
-        await assert.rejects(() => parseArgv(startReviewerParams, ['/tmp/artifact.md', '--kind', 'bad']), (err) => { assert.match(err.message, /must be one of/); return true; });
-    });
-    test('--spec-path optional, becomes specPath', async () => {
-        const result = await parseArgv(startReviewerParams, [
-            '/tmp/artifact.md', '--kind', 'plan', '--spec-path', '/tmp/spec.md',
-        ]);
-        assert.equal(result['specPath'], '/tmp/spec.md');
-    });
-});
-// ---------------------------------------------------------------------------
-// job read list
-// ---------------------------------------------------------------------------
-describe('job read list', () => {
-    test('defaults: limit=20, cursor=undefined', async () => {
-        const result = await parseArgv(readListParams, []);
-        assert.equal(result['limit'], 20);
-        assert.equal(result['cursor'], undefined);
-    });
-    test('--limit N parsed as int', async () => {
-        const result = await parseArgv(readListParams, ['--limit', '50']);
-        assert.equal(result['limit'], 50);
-    });
-    test('--limit with non-integer throws', async () => {
-        await assert.rejects(() => parseArgv(readListParams, ['--limit', 'abc']), (err) => { assert.match(err.message, /must be an integer/); return true; });
-    });
-    test('--cursor opaque token', async () => {
-        const result = await parseArgv(readListParams, ['--cursor', 'tok_abc123']);
-        assert.equal(result['cursor'], 'tok_abc123');
-    });
-    test('--limit and --cursor together', async () => {
-        const result = await parseArgv(readListParams, ['--limit', '5', '--cursor', 'next_page']);
-        assert.equal(result['limit'], 5);
-        assert.equal(result['cursor'], 'next_page');
-    });
-});
-// ---------------------------------------------------------------------------
-// job read status
-// ---------------------------------------------------------------------------
-describe('job read status', () => {
-    test('positional job_id required', async () => {
-        await assert.rejects(() => parseArgv(readStatusParams, []), (err) => { assert.match(err.message, /required parameter is missing/); return true; });
-    });
-    test('positional job_id parsed', async () => {
-        const result = await parseArgv(readStatusParams, ['job-abc-123']);
-        assert.equal(result['job_id'], 'job-abc-123');
-    });
-});
-// ---------------------------------------------------------------------------
-// job read result
-// ---------------------------------------------------------------------------
-describe('job read result', () => {
-    test('positional job_id required', async () => {
-        await assert.rejects(() => parseArgv(readResultParams, []), (err) => { assert.match(err.message, /required parameter is missing/); return true; });
-    });
-    test('positional job_id without --wait', async () => {
-        const result = await parseArgv(readResultParams, ['job-xyz']);
-        assert.equal(result['job_id'], 'job-xyz');
-        assert.equal(result['wait'], false);
-    });
-    test('--wait presence = true', async () => {
-        const result = await parseArgv(readResultParams, ['job-xyz', '--wait']);
-        assert.equal(result['wait'], true);
-    });
-    test('--wait=value rejected (bool takes no value)', async () => {
-        await assert.rejects(() => parseArgv(readResultParams, ['job-xyz', '--wait=true']), (err) => { assert.match(err.message, /takes no value/); return true; });
-    });
-});
-// ---------------------------------------------------------------------------
-// job read logs
-// ---------------------------------------------------------------------------
-describe('job read logs', () => {
-    test('positional job_id required', async () => {
-        await assert.rejects(() => parseArgv(readLogsParams, []), (err) => { assert.match(err.message, /required parameter is missing/); return true; });
-    });
-    test('defaults: level=info, follow=false', async () => {
-        const result = await parseArgv(readLogsParams, ['job-abc']);
-        assert.equal(result['job_id'], 'job-abc');
-        assert.equal(result['level'], 'info');
-        assert.equal(result['follow'], false);
-    });
-    test('--follow presence = true', async () => {
-        const result = await parseArgv(readLogsParams, ['job-abc', '--follow']);
-        assert.equal(result['follow'], true);
-    });
-    test('--follow=value rejected', async () => {
-        await assert.rejects(() => parseArgv(readLogsParams, ['job-abc', '--follow=true']), (err) => { assert.match(err.message, /takes no value/); return true; });
-    });
-    test('--level valid enum', async () => {
-        const result = await parseArgv(readLogsParams, ['job-abc', '--level', 'debug']);
-        assert.equal(result['level'], 'debug');
-    });
-    test('--level invalid enum throws', async () => {
-        await assert.rejects(() => parseArgv(readLogsParams, ['job-abc', '--level', 'trace']), (err) => { assert.match(err.message, /must be one of/); return true; });
-    });
-    test('--since and --until optional strings', async () => {
-        const result = await parseArgv(readLogsParams, [
-            'job-abc', '--since', '2025-01-01T00:00:00Z', '--until', '2025-01-02T00:00:00Z',
-        ]);
-        assert.equal(result['since'], '2025-01-01T00:00:00Z');
-        assert.equal(result['until'], '2025-01-02T00:00:00Z');
-    });
-});
-// ---------------------------------------------------------------------------
-// job submit
-// ---------------------------------------------------------------------------
-describe('job submit', () => {
-    test('positional job_id + defaults: status=done, killPane=false', async () => {
-        const result = await parseArgv(submitParams, ['job-abc']);
-        assert.equal(result['job_id'], 'job-abc');
-        assert.equal(result['status'], 'done');
-        assert.equal(result['killPane'], false);
-    });
-    test('--status failed parsed', async () => {
-        const result = await parseArgv(submitParams, ['job-abc', '--status', 'failed', '--reason', 'broken']);
-        assert.equal(result['status'], 'failed');
-        assert.equal(result['reason'], 'broken');
-    });
-    test('--status invalid enum throws', async () => {
-        await assert.rejects(() => parseArgv(submitParams, ['job-abc', '--status', 'bogus']), (err) => { assert.match(err.message, /must be one of/); return true; });
-    });
-    test('--kill-pane presence = true, killPane key', async () => {
-        const result = await parseArgv(submitParams, ['job-abc', '--kill-pane']);
-        assert.equal(result['killPane'], true);
-    });
-    test('missing positional job_id throws missing_parameter', async () => {
-        await assert.rejects(() => parseArgv(submitParams, []), (err) => { assert.match(err.message, /required parameter is missing/); return true; });
-    });
-    test('--context-file no longer accepted', async () => {
-        await assert.rejects(() => parseArgv(submitParams, ['job-abc', '--context-file', '/tmp/anything']), (err) => { assert.match(err.message, /unknown flag: --context-file/); return true; });
-    });
-});
-// ---------------------------------------------------------------------------
-// job cancel
-// ---------------------------------------------------------------------------
-describe('job cancel', () => {
-    test('positional job_id required', async () => {
-        await assert.rejects(() => parseArgv(cancelParams, []), (err) => { assert.match(err.message, /required parameter is missing/); return true; });
-    });
-    test('positional job_id parsed', async () => {
-        const result = await parseArgv(cancelParams, ['job-abc-123']);
-        assert.equal(result['job_id'], 'job-abc-123');
-    });
-});
-// ---------------------------------------------------------------------------
-// job _fail
-// ---------------------------------------------------------------------------
-describe('job _fail', () => {
-    test('positional job_id required', async () => {
-        await assert.rejects(() => parseArgv(failParams, []), (err) => { assert.match(err.message, /required parameter is missing/); return true; });
-    });
-    test('positional job_id parsed', async () => {
-        const result = await parseArgv(failParams, ['job-fail-001']);
-        assert.equal(result['job_id'], 'job-fail-001');
-    });
-});

package/dist/core/__tests__/jobs.test.js

@@ -1,98 +0,0 @@
-// Tests for jobs.ts result-file storage (markdown vs json paths).
-//
-// Run with: node --import tsx/esm --test src/core/__tests__/jobs.test.ts
-import { test, describe, before, after } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdirSync, rmSync, existsSync, readFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { createJob, writeResult, writeMarkdownResult, readResult, recordJobPane, jobStatus, } from '../jobs.js';
-let stateDir;
-let origXdg;
-before(() => {
-    stateDir = join(tmpdir(), `crtr-jobs-test-${Date.now()}`);
-    mkdirSync(stateDir, { recursive: true });
-    origXdg = process.env['XDG_STATE_HOME'];
-    process.env['XDG_STATE_HOME'] = stateDir;
-});
-after(() => {
-    if (origXdg === undefined) {
-        delete process.env['XDG_STATE_HOME'];
-    }
-    else {
-        process.env['XDG_STATE_HOME'] = origXdg;
-    }
-    rmSync(stateDir, { recursive: true, force: true });
-});
-describe('writeMarkdownResult + readResult round-trip', () => {
-    test('done with body writes result.md, parses frontmatter back', async () => {
-        const { jobId, dir } = createJob('prompt', { cwd: '/tmp' });
-        const body = '**Summary:** all good\n\nMore details on the next line.\n';
-        writeMarkdownResult(jobId, body, 'done');
-        assert.ok(existsSync(join(dir, 'result.md')), 'result.md should exist');
-        assert.ok(!existsSync(join(dir, 'result.json')), 'result.json should NOT exist on md path');
-        const raw = readFileSync(join(dir, 'result.md'), 'utf8');
-        assert.match(raw, /^---\nstatus: done\nwritten_at: \d{4}-\d{2}-\d{2}T/);
-        assert.ok(raw.endsWith(body), 'body preserved at end of file');
-        const r = await readResult(jobId, { waitMs: 0 });
-        assert.equal(r.status, 'done');
-        assert.equal(r.result_md, body);
-        assert.equal(r.reason, undefined);
-        assert.equal(r.result, undefined);
-    });
-    test('failed with reason writes reason into frontmatter and reads it back', async () => {
-        const { jobId } = createJob('prompt', { cwd: '/tmp' });
-        writeMarkdownResult(jobId, '', 'failed', 'broke: had "quoted" parts and a\nnewline');
-        const r = await readResult(jobId, { waitMs: 0 });
-        assert.equal(r.status, 'failed');
-        assert.equal(r.result_md, '');
-        assert.equal(r.reason, 'broke: had "quoted" parts and a\nnewline');
-    });
-    test('writeResult (JSON) writes result.json and read still works', async () => {
-        const { jobId, dir } = createJob('prompt', { cwd: '/tmp' });
-        writeResult(jobId, { feedback: 'approved', n: 3 }, 'done');
-        assert.ok(existsSync(join(dir, 'result.json')));
-        assert.ok(!existsSync(join(dir, 'result.md')));
-        const r = await readResult(jobId, { waitMs: 0 });
-        assert.equal(r.status, 'done');
-        assert.deepEqual(r.result, { feedback: 'approved', n: 3 });
-        assert.equal(r.result_md, undefined);
-    });
-    test('readResult with no result file and waitMs=0 returns timeout', async () => {
-        const { jobId } = createJob('prompt', { cwd: '/tmp' });
-        const r = await readResult(jobId, { waitMs: 0 });
-        assert.equal(r.status, 'timeout');
-    });
-});
-describe('closed-pane reaping (zombie prevention)', () => {
-    test('live job whose recorded pane is gone is reaped to closed on status read', () => {
-        const { jobId } = createJob('prompt', { cwd: '/tmp' });
-        // A pane id that cannot exist on any tmux server.
-        recordJobPane(jobId, '%999999999');
-        const status = jobStatus(jobId);
-        assert.equal(status.state, 'closed');
-    });
-    test('reaped job exposes a closed result explaining the closed pane', async () => {
-        const { jobId } = createJob('prompt', { cwd: '/tmp' });
-        recordJobPane(jobId, '%999999999');
-        // Trigger the reaper.
-        jobStatus(jobId);
-        const r = await readResult(jobId, { waitMs: 0 });
-        assert.equal(r.status, 'closed');
-        assert.match(r.reason ?? '', /pane closed/);
-    });
-    test('job with no recorded pane is NOT reaped (stays live)', () => {
-        const { jobId } = createJob('prompt', { cwd: '/tmp' });
-        const status = jobStatus(jobId);
-        assert.equal(status.state, 'live');
-    });
-    test('already-submitted job is never overwritten by the reaper', async () => {
-        const { jobId } = createJob('prompt', { cwd: '/tmp' });
-        recordJobPane(jobId, '%999999999');
-        writeMarkdownResult(jobId, '**done**\n', 'done');
-        jobStatus(jobId);
-        const r = await readResult(jobId, { waitMs: 0 });
-        assert.equal(r.status, 'done');
-        assert.equal(r.result_md, '**done**\n');
-    });
-});

package/dist/core/__tests__/spawn.test.js

@@ -1,138 +0,0 @@
-// Tests for agent-CLI selection in spawn.ts (detectAgentKind + buildAgentCommand).
-//
-// Run with: node --import tsx/esm --test src/core/__tests__/spawn.test.ts
-import { test, describe, afterEach } from 'node:test';
-import assert from 'node:assert/strict';
-import { detectAgentKind, buildAgentCommand, buildAgentPrintArgv, buildAgentPrintCommand, normalizeModelForKind, subagentSessionName, } from '../spawn.js';
-const origPi = process.env['PI_CODING_AGENT'];
-afterEach(() => {
-    if (origPi === undefined)
-        delete process.env['PI_CODING_AGENT'];
-    else
-        process.env['PI_CODING_AGENT'] = origPi;
-});
-describe('subagentSessionName', () => {
-    test('derives a deterministic, tmux-safe name from a pane id', () => {
-        assert.equal(subagentSessionName('%5'), 'crtr-agents-5');
-        assert.equal(subagentSessionName('%23'), 'crtr-agents-23');
-    });
-    test('is stable for the same pane id and distinct across panes', () => {
-        assert.equal(subagentSessionName('%7'), subagentSessionName('%7'));
-        assert.notEqual(subagentSessionName('%7'), subagentSessionName('%8'));
-    });
-    test('strips characters tmux would treat specially', () => {
-        assert.equal(subagentSessionName('%1.2'), 'crtr-agents-12');
-        assert.match(subagentSessionName('%99'), /^crtr-agents-[a-zA-Z0-9]+$/);
-    });
-});
-describe('detectAgentKind', () => {
-    test('returns pi when PI_CODING_AGENT=true', () => {
-        process.env['PI_CODING_AGENT'] = 'true';
-        assert.equal(detectAgentKind(), 'pi');
-    });
-    test('defaults to claude when no signal is present', () => {
-        delete process.env['PI_CODING_AGENT'];
-        assert.equal(detectAgentKind(), 'claude');
-    });
-});
-describe('buildAgentCommand: claude', () => {
-    test('fresh prompt uses --dangerously-skip-permissions and quotes the prompt', () => {
-        const cmd = buildAgentCommand({ prompt: 'do the thing', name: 'worker-1' }, 'claude');
-        assert.equal(cmd, "claude -n 'worker-1' --dangerously-skip-permissions 'do the thing'");
-    });
-    test('fork uses --resume <id> --fork-session', () => {
-        const cmd = buildAgentCommand({ prompt: 'p', fork: { sessionId: 'abc-123' } }, 'claude');
-        assert.equal(cmd, "claude --resume 'abc-123' --fork-session --dangerously-skip-permissions 'p'");
-    });
-});
-describe('buildAgentCommand: pi', () => {
-    test('fresh prompt has no skip-permissions flag (pi has no permission popups)', () => {
-        const cmd = buildAgentCommand({ prompt: 'do the thing', name: 'worker-1' }, 'pi');
-        assert.equal(cmd, "pi -n 'worker-1' 'do the thing'");
-        assert.ok(!cmd.includes('--dangerously-skip-permissions'));
-    });
-    test('fork uses --fork <id>', () => {
-        const cmd = buildAgentCommand({ prompt: 'p', fork: { sessionId: 'abc-123' } }, 'pi');
-        assert.equal(cmd, "pi --fork 'abc-123' 'p'");
-    });
-    test('single-quotes in the prompt are escaped safely', () => {
-        const cmd = buildAgentCommand({ prompt: "it's fine" }, 'pi');
-        assert.equal(cmd, "pi 'it'\\''s fine'");
-    });
-});
-describe('buildAgentCommand: subagent persona (systemPrompt/model/tools)', () => {
-    test('pi emits --model, --tools, and --append-system-prompt before the prompt', () => {
-        const cmd = buildAgentCommand({ prompt: 'task', name: 'scout', systemPrompt: 'You are a scout.', model: 'haiku', tools: ['read', 'grep'] }, 'pi');
-        assert.equal(cmd, "pi -n 'scout' --model 'anthropic/haiku' --tools 'read,grep' --append-system-prompt 'You are a scout.' 'task'");
-    });
-    test('claude emits --model and --append-system-prompt but NOT --tools (different tool model)', () => {
-        const cmd = buildAgentCommand({ prompt: 'task', systemPrompt: 'persona', model: 'sonnet', tools: ['read', 'grep'] }, 'claude');
-        assert.ok(cmd.includes("--model 'sonnet'"));
-        assert.ok(cmd.includes("--append-system-prompt 'persona'"));
-        assert.ok(!cmd.includes('--tools'));
-    });
-    test('omitted persona fields add no flags', () => {
-        const cmd = buildAgentCommand({ prompt: 'task' }, 'pi');
-        assert.equal(cmd, "pi 'task'");
-    });
-});
-describe('buildAgentPrintArgv: subagent persona', () => {
-    test('pi threads model/tools/system prompt as discrete args', () => {
-        const { args } = buildAgentPrintArgv({ prompt: 'task', systemPrompt: 'persona', model: 'haiku', tools: ['read', 'bash'] }, 'pi');
-        assert.deepEqual(args, ['--model', 'anthropic/haiku', '--tools', 'read,bash', '--append-system-prompt', 'persona', '-p', 'task']);
-    });
-    test('claude threads model/system prompt but not tools', () => {
-        const { args } = buildAgentPrintArgv({ prompt: 'task', systemPrompt: 'persona', model: 'sonnet', tools: ['read'] }, 'claude');
-        assert.deepEqual(args, ['--model', 'sonnet', '--append-system-prompt', 'persona', '-p', '--dangerously-skip-permissions', 'task']);
-    });
-});
-describe('normalizeModelForKind: pi Claude-alias resolution', () => {
-    test('pins bare Claude aliases to the anthropic provider under pi', () => {
-        assert.equal(normalizeModelForKind('sonnet', 'pi'), 'anthropic/sonnet');
-        assert.equal(normalizeModelForKind('opus', 'pi'), 'anthropic/opus');
-        assert.equal(normalizeModelForKind('haiku', 'pi'), 'anthropic/haiku');
-    });
-    test('preserves a :thinking suffix when pinning the provider', () => {
-        assert.equal(normalizeModelForKind('sonnet:high', 'pi'), 'anthropic/sonnet:high');
-    });
-    test('leaves provider-prefixed and concrete ids untouched under pi', () => {
-        assert.equal(normalizeModelForKind('anthropic/sonnet', 'pi'), 'anthropic/sonnet');
-        assert.equal(normalizeModelForKind('openai/gpt-4o', 'pi'), 'openai/gpt-4o');
-        assert.equal(normalizeModelForKind('claude-sonnet-4-6', 'pi'), 'claude-sonnet-4-6');
-        assert.equal(normalizeModelForKind('gpt-4o-mini', 'pi'), 'gpt-4o-mini');
-    });
-    test('never rewrites for the claude CLI (native alias support)', () => {
-        assert.equal(normalizeModelForKind('sonnet', 'claude'), 'sonnet');
-        assert.equal(normalizeModelForKind('opus', 'claude'), 'opus');
-    });
-});
-describe('buildAgentCommand: defaults to detected kind', () => {
-    test('uses pi when PI_CODING_AGENT=true and no explicit kind passed', () => {
-        process.env['PI_CODING_AGENT'] = 'true';
-        const cmd = buildAgentCommand({ prompt: 'hi' });
-        assert.ok(cmd.startsWith('pi '));
-    });
-});
-describe('buildAgentPrintArgv (headless print mode)', () => {
-    test('pi uses -p and no skip-permissions flag', () => {
-        const { cmd, args } = buildAgentPrintArgv({ prompt: 'do it', name: 'w1' }, 'pi');
-        assert.equal(cmd, 'pi');
-        assert.deepEqual(args, ['-n', 'w1', '-p', 'do it']);
-        assert.ok(!args.includes('--dangerously-skip-permissions'));
-    });
-    test('claude uses -p plus --dangerously-skip-permissions', () => {
-        const { cmd, args } = buildAgentPrintArgv({ prompt: 'do it' }, 'claude');
-        assert.equal(cmd, 'claude');
-        assert.deepEqual(args, ['-p', '--dangerously-skip-permissions', 'do it']);
-    });
-    test('argv passes the prompt as a discrete arg (no shell quoting)', () => {
-        const { args } = buildAgentPrintArgv({ prompt: "it's $weird" }, 'pi');
-        assert.equal(args[args.length - 1], "it's $weird");
-    });
-});
-describe('buildAgentPrintCommand (shell string)', () => {
-    test('pi prints with -p and shell-quotes the prompt', () => {
-        const cmd = buildAgentPrintCommand({ prompt: "it's fine" }, 'pi');
-        assert.equal(cmd, "pi '-p' 'it'\\''s fine'");
-    });
-});

package/dist/core/__tests__/subagents.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/core/__tests__/subagents.test.js

@@ -1,75 +0,0 @@
-// Tests for subagent discovery, resolution, and frontmatter parsing.
-//
-// Run with: node --import tsx/esm --test src/core/__tests__/subagents.test.ts
-import { test, describe, before, after } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { listSubagents, resolveSubagent, subagentId } from '../subagents.js';
-import { resetScopeCache } from '../scope.js';
-import { parseFrontmatterGeneric } from '../frontmatter.js';
-describe('parseFrontmatterGeneric', () => {
-    test('returns raw record including tools/model fields skills ignore', () => {
-        const src = '---\nname: scout\ndescription: recon\nmodel: haiku\ntools: read, grep, bash\n---\nBody here.\n';
-        const { data, body } = parseFrontmatterGeneric(src);
-        assert.ok(data !== null);
-        assert.equal(data['name'], 'scout');
-        assert.equal(data['description'], 'recon');
-        assert.equal(data['model'], 'haiku');
-        assert.equal(data['tools'], 'read, grep, bash');
-        assert.equal(body, 'Body here.\n');
-    });
-    test('list-style tools parse to an array', () => {
-        const src = '---\nname: x\ndescription: d\ntools:\n  - read\n  - bash\n---\nb\n';
-        const { data } = parseFrontmatterGeneric(src);
-        assert.deepEqual(data['tools'], ['read', 'bash']);
-    });
-    test('no frontmatter yields null data', () => {
-        const { data, body } = parseFrontmatterGeneric('just a body');
-        assert.equal(data, null);
-        assert.equal(body, 'just a body');
-    });
-});
-describe('subagent discovery (project scope)', () => {
-    let dir;
-    const origCwd = process.cwd();
-    before(() => {
-        dir = mkdtempSync(join(tmpdir(), 'crtr-subagents-'));
-        const agents = join(dir, '.crouter', 'agents');
-        mkdirSync(agents, { recursive: true });
-        writeFileSync(join(dir, '.crouter', 'config.json'), '{}');
-        writeFileSync(join(agents, 'scout.md'), '---\nname: scout\ndescription: Fast recon\nmodel: haiku\ntools: read, grep\n---\nYou are a scout.\n');
-        writeFileSync(join(agents, 'reviewer.md'), '---\nname: reviewer\ndescription: Code review\n---\nYou review code.\n');
-        // Missing description → skipped from listings.
-        writeFileSync(join(agents, 'broken.md'), '---\nname: broken\n---\nno description\n');
-        // Name defaults to filename stem when frontmatter omits it.
-        writeFileSync(join(agents, 'stemmed.md'), '---\ndescription: named by file\n---\nbody\n');
-        process.chdir(dir);
-        resetScopeCache();
-    });
-    after(() => {
-        process.chdir(origCwd);
-        resetScopeCache();
-        rmSync(dir, { recursive: true, force: true });
-    });
-    test('listSubagents finds valid agents and skips description-less files', () => {
-        const ids = listSubagents('project').map(subagentId).sort();
-        assert.deepEqual(ids, ['reviewer', 'scout', 'stemmed']);
-    });
-    test('frontmatter tools comma-string coerces to array; model carried', () => {
-        const scout = resolveSubagent('scout', { scope: 'project' });
-        assert.deepEqual(scout.frontmatter.tools, ['read', 'grep']);
-        assert.equal(scout.frontmatter.model, 'haiku');
-        assert.equal(scout.systemPrompt.trim(), 'You are a scout.');
-        assert.equal(scout.plugin, '_');
-    });
-    test('name defaults to filename stem', () => {
-        const a = resolveSubagent('stemmed', { scope: 'project' });
-        assert.equal(a.name, 'stemmed');
-        assert.equal(a.frontmatter.description, 'named by file');
-    });
-    test('resolveSubagent throws notFound for unknown name', () => {
-        assert.throws(() => resolveSubagent('nope', { scope: 'project' }), /subagent not found/);
-    });
-});