@crouton-kit/crouter 0.3.3 → 0.3.11

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

@@ -1,13 +1,10 @@
-// Tests for the job subtree argv migration.
-// Exercises parseArgv against each leaf's param schema directly — no subprocess,
-// no tmux, no filesystem side-effects from the handler.
+// 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 { writeFileSync, mkdirSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
 import { parseArgv } from '../command.js';
 // ---------------------------------------------------------------------------
 // Param schemas extracted from each leaf (mirrors job.ts exactly)
@@ -51,9 +48,16 @@ const readLogsParams = [
     { 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: 'context-file', name: 'result', 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 = [
@@ -63,27 +67,9 @@ const failParams = [
     { kind: 'positional', name: 'job_id', type: 'string', required: true, constraint: '' },
 ];
 // ---------------------------------------------------------------------------
-// Helpers
+// agent new (formerly job start prompt)
 // ---------------------------------------------------------------------------
-let tmpDir;
-function setup() {
-    tmpDir = join(tmpdir(), `crtr-job-test-${Date.now()}`);
-    mkdirSync(tmpDir, { recursive: true });
-}
-function teardown() {
-    if (tmpDir !== undefined) {
-        rmSync(tmpDir, { recursive: true, force: true });
-    }
-}
-function writeTmpJson(name, obj) {
-    const p = join(tmpDir, name);
-    writeFileSync(p, JSON.stringify(obj), 'utf8');
-    return p;
-}
-// ---------------------------------------------------------------------------
-// job start prompt
-// ---------------------------------------------------------------------------
-describe('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 () => {
@@ -105,9 +91,9 @@ describe('job start prompt', () => {
     });
 });
 // ---------------------------------------------------------------------------
-// job start fork
+// agent fork (formerly job start fork)
 // ---------------------------------------------------------------------------
-describe('job start fork', () => {
+describe('agent fork', () => {
     test('no args parses cleanly', async () => {
         const result = await parseArgv(startForkParams, []);
         assert.equal(result['cwd'], undefined);
@@ -121,9 +107,9 @@ describe('job start fork', () => {
     });
 });
 // ---------------------------------------------------------------------------
-// job start planner
+// mode planner (formerly job start planner)
 // ---------------------------------------------------------------------------
-describe('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; });
     });
@@ -139,9 +125,9 @@ describe('job start planner', () => {
     });
 });
 // ---------------------------------------------------------------------------
-// job start implementer
+// mode implementer (formerly job start implementer)
 // ---------------------------------------------------------------------------
-describe('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; });
     });
@@ -151,9 +137,9 @@ describe('job start implementer', () => {
     });
 });
 // ---------------------------------------------------------------------------
-// job start reviewer
+// mode reviewer (formerly job start reviewer)
 // ---------------------------------------------------------------------------
-describe('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; });
     });
@@ -273,51 +259,29 @@ describe('job read logs', () => {
 // job submit
 // ---------------------------------------------------------------------------
 describe('job submit', () => {
-    // setup/teardown wraps tests via explicit calls since node:test lacks
-    // per-describe lifecycle hooks in older versions.
-    test('--context-file with valid JSON object', async () => {
-        setup();
-        try {
-            const p = writeTmpJson('result.json', { status: 'done', summary: 'all good' });
-            const result = await parseArgv(submitParams, ['job-abc', '--context-file', p]);
-            assert.equal(result['job_id'], 'job-abc');
-            assert.deepEqual(result['result'], { status: 'done', summary: 'all good' });
-            assert.equal(result['killPane'], false);
-        }
-        finally {
-            teardown();
-        }
+    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 () => {
-        setup();
-        try {
-            const p = writeTmpJson('result.json', { status: 'done' });
-            const result = await parseArgv(submitParams, ['job-abc', '--context-file', p, '--kill-pane']);
-            assert.equal(result['killPane'], true);
-        }
-        finally {
-            teardown();
-        }
-    });
-    test('missing --context-file throws missing_parameter', async () => {
-        await assert.rejects(() => parseArgv(submitParams, ['job-abc']), (err) => { assert.match(err.message, /required parameter is missing/); return true; });
+        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 with non-existent file throws invalid_type', async () => {
-        await assert.rejects(() => parseArgv(submitParams, ['job-abc', '--context-file', '/no/such/file.json']), (err) => { assert.match(err.message, /cannot read file/); return true; });
-    });
-    test('--context-file with invalid JSON throws invalid_type', async () => {
-        setup();
-        try {
-            const p = join(tmpDir, 'bad.json');
-            writeFileSync(p, 'not json', 'utf8');
-            await assert.rejects(() => parseArgv(submitParams, ['job-abc', '--context-file', p]), (err) => { assert.match(err.message, /not valid JSON/); return true; });
-        }
-        finally {
-            teardown();
-        }
+    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; });
     });
 });
 // ---------------------------------------------------------------------------

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

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

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

@@ -0,0 +1,98 @@
+// 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__/resolver.test.d.ts

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

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

@@ -0,0 +1,181 @@
+// Tests for parseSkillQualifier (slash-only form) and config migration.
+//
+// Run with: node --import tsx/esm --test 'src/core/__tests__/resolver.test.ts'
+import { test, describe, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { parseSkillQualifier, resolveSkill } from '../resolver.js';
+import { resetScopeCache } from '../scope.js';
+import { CrtrError } from '../errors.js';
+import { InputError } from '../io.js';
+import { readConfig } from '../config.js';
+import { SCHEMA_VERSION } from '../../types.js';
+// ---------------------------------------------------------------------------
+// parseSkillQualifier — slash-only form
+// ---------------------------------------------------------------------------
+describe('parseSkillQualifier', () => {
+    test('bare name returns single segment', () => {
+        const r = parseSkillQualifier('foo');
+        assert.deepEqual(r, { segments: ['foo'] });
+    });
+    test('plugin/name returns two segments', () => {
+        const r = parseSkillQualifier('ai/interface');
+        assert.deepEqual(r, { segments: ['ai', 'interface'] });
+    });
+    test('plugin/nested/name returns three segments', () => {
+        const r = parseSkillQualifier('ai/interface/cli-design');
+        assert.deepEqual(r, { segments: ['ai', 'interface', 'cli-design'] });
+    });
+    test('scope-qualified user/name sets scope, single segment', () => {
+        const r = parseSkillQualifier('user/my-skill');
+        assert.deepEqual(r, { scope: 'user', segments: ['my-skill'] });
+    });
+    test('scope-qualified project/name sets scope', () => {
+        const r = parseSkillQualifier('project/my-skill');
+        assert.deepEqual(r, { scope: 'project', segments: ['my-skill'] });
+    });
+    test('scope-qualified user/ai/x/y sets scope and leaves rest as segments', () => {
+        const r = parseSkillQualifier('user/ai/x/y');
+        assert.deepEqual(r, { scope: 'user', segments: ['ai', 'x', 'y'] });
+    });
+    test('colon in input throws InputError with invalid_qualifier', () => {
+        assert.throws(() => parseSkillQualifier('ai:interface/cli-design'), (e) => {
+            assert.ok(e instanceof InputError, 'should be InputError');
+            assert.equal(e.payload.error, 'invalid_qualifier');
+            assert.equal(e.payload.received, 'ai:interface/cli-design');
+            assert.ok(e.payload.next.includes('ai/interface/cli-design'), `next should contain slash form, got: ${e.payload.next}`);
+            return true;
+        });
+    });
+    test('legacy scope:name form throws invalid_qualifier', () => {
+        assert.throws(() => parseSkillQualifier('user:my-skill'), (e) => {
+            assert.ok(e instanceof InputError);
+            assert.equal(e.payload.error, 'invalid_qualifier');
+            assert.ok(e.payload.next.includes('user/my-skill'));
+            return true;
+        });
+    });
+    test('legacy scope:plugin/name form throws invalid_qualifier', () => {
+        assert.throws(() => parseSkillQualifier('user:ai/interface/cli-design'), (e) => {
+            assert.ok(e instanceof InputError);
+            assert.equal(e.payload.error, 'invalid_qualifier');
+            assert.ok(e.payload.next.includes('user/ai/interface/cli-design'));
+            return true;
+        });
+    });
+});
+// ---------------------------------------------------------------------------
+// Config migration: colon keys → slash keys on readConfig with old schema_version
+// ---------------------------------------------------------------------------
+describe('config migration: skill keys colon → slash', () => {
+    let testHomeDir;
+    let origHome;
+    let crouterDir;
+    before(() => {
+        testHomeDir = join(tmpdir(), `crtr-resolver-test-${Date.now()}`);
+        mkdirSync(testHomeDir, { recursive: true });
+        origHome = process.env['HOME'];
+        process.env['HOME'] = testHomeDir;
+        crouterDir = join(testHomeDir, '.crouter');
+        mkdirSync(crouterDir, { recursive: true });
+    });
+    after(() => {
+        if (origHome === undefined) {
+            delete process.env['HOME'];
+        }
+        else {
+            process.env['HOME'] = origHome;
+        }
+        rmSync(testHomeDir, { recursive: true, force: true });
+    });
+    test('colon keys are migrated to slash keys and written with new schema_version', () => {
+        const oldConfig = {
+            schema_version: 1,
+            marketplaces: {},
+            plugins: {},
+            skills: {
+                'ai:foo': { enabled: true },
+                'ai:interface/cli-design': { enabled: false },
+            },
+            auto_update: { crtr: 'notify', content: 'notify', interval_hours: 24 },
+            max_panes_per_window: 3,
+        };
+        writeFileSync(join(crouterDir, 'config.json'), JSON.stringify(oldConfig), 'utf8');
+        const cfg = readConfig('user');
+        assert.ok(!('ai:foo' in cfg.skills), 'old colon key should be gone');
+        assert.ok('ai/foo' in cfg.skills, 'slash key should exist');
+        assert.equal(cfg.skills['ai/foo']?.enabled, true, 'enabled state preserved');
+        assert.ok(!('ai:interface/cli-design' in cfg.skills), 'old colon key should be gone');
+        assert.ok('ai/interface/cli-design' in cfg.skills, 'slash key should exist for nested');
+        assert.equal(cfg.skills['ai/interface/cli-design']?.enabled, false, 'disabled state preserved');
+        assert.equal(cfg.schema_version, SCHEMA_VERSION, 'schema_version bumped to current');
+    });
+});
+// ---------------------------------------------------------------------------
+// resolveSkill — leaf-name fallback
+// ---------------------------------------------------------------------------
+describe('resolveSkill leaf-name fallback', () => {
+    let testHomeDir;
+    let origHome;
+    function writePluginSkill(plugin, skillPath) {
+        const root = join(testHomeDir, '.crouter', 'plugins', plugin);
+        mkdirSync(join(root, '.crouter-plugin'), { recursive: true });
+        writeFileSync(join(root, '.crouter-plugin', 'plugin.json'), JSON.stringify({ name: plugin, version: '0.0.1' }), 'utf8');
+        const skillDir = join(root, 'skills', ...skillPath.split('/'));
+        mkdirSync(skillDir, { recursive: true });
+        writeFileSync(join(skillDir, 'SKILL.md'), `---\nname: ${skillPath.split('/').pop()}\n---\nbody`, 'utf8');
+    }
+    before(() => {
+        testHomeDir = join(tmpdir(), `crtr-leaf-test-${Date.now()}`);
+        mkdirSync(testHomeDir, { recursive: true });
+        origHome = process.env['HOME'];
+        process.env['HOME'] = testHomeDir;
+        resetScopeCache();
+        // Unique leaf: only one plugin has it, reached via nested path.
+        writePluginSkill('ai', 'interface/cli-design');
+        // Colliding leaf: two plugins both expose `dup` at different paths.
+        writePluginSkill('pa', 'x/dup');
+        writePluginSkill('pb', 'y/dup');
+    });
+    after(() => {
+        if (origHome === undefined)
+            delete process.env['HOME'];
+        else
+            process.env['HOME'] = origHome;
+        resetScopeCache();
+        rmSync(testHomeDir, { recursive: true, force: true });
+    });
+    test('bare leaf name resolves to the nested skill', () => {
+        const s = resolveSkill('cli-design');
+        assert.equal(s.name, 'interface/cli-design');
+        assert.equal(s.plugin, 'ai');
+    });
+    test('full path still resolves directly', () => {
+        const s = resolveSkill('ai/interface/cli-design');
+        assert.equal(s.name, 'interface/cli-design');
+        assert.equal(s.plugin, 'ai');
+    });
+    test('colliding leaf name throws ambiguous listing full paths', () => {
+        assert.throws(() => resolveSkill('dup'), (e) => {
+            assert.ok(e instanceof CrtrError, 'should be CrtrError');
+            assert.equal(e.code, 'ambiguous');
+            assert.match(e.message, /pa\/x\/dup/);
+            assert.match(e.message, /pb\/y\/dup/);
+            return true;
+        });
+    });
+    test('colliding leaf is resolvable via full path', () => {
+        const s = resolveSkill('pb/y/dup');
+        assert.equal(s.plugin, 'pb');
+        assert.equal(s.name, 'y/dup');
+    });
+    test('unknown leaf still throws not_found', () => {
+        assert.throws(() => resolveSkill('no-such-leaf-xyz'), (e) => {
+            assert.ok(e instanceof CrtrError);
+            assert.equal(e.code, 'not_found');
+            return true;
+        });
+    });
+});

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

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

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

@@ -0,0 +1,138 @@
+// 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

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