@pulsehub/runner 0.1.3 → 0.1.5

package/test/integration.test.js

@@ -0,0 +1,269 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { generateKeyPairSync, sign } from 'node:crypto';
+import { createServer } from 'node:http';
+import { mkdtemp, mkdir, readFile, writeFile, rm, access } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { paths, ensureDataDir, writeCredential } from '../src/config.js';
+import { jobPayload } from '../src/job.js';
+import { command } from '../src/process.js';
+import { inspectReadiness } from '../src/readiness.js';
+import { runOnce, recoverInterruptedWork, withRunnerLock } from '../src/runtime.js';
+
+const exists = (file) => access(file).then(() => true).catch(() => false);
+async function git(args) { const result = await command('git', args); assert.equal(result.code, 0, result.output); return result.output.trim(); }
+
+async function fixture(kind, callback) {
+  const root = await mkdtemp(join(tmpdir(), 'pulse-runtime-'));
+  const saved = { ...process.env };
+  process.env.PULSE_RUNNER_HOME = join(root, 'runner');
+  const source = join(root, 'source');
+  const trace = join(root, 'trace.json');
+  const fake = join(root, 'provider.mjs');
+  await writeFile(fake, `
+import { writeFileSync, readFileSync } from 'node:fs';
+import { spawn, spawnSync } from 'node:child_process';
+const args = process.argv.slice(2);
+const settings = JSON.parse(readFileSync(${JSON.stringify(join(root, 'settings.json'))}, 'utf8'));
+if (args.includes('--version')) console.log('fixture-cli');
+else if (args[0] === 'login') process.exit(settings.session ? 0 : 1);
+else if (args[0] === 'auth') console.log(JSON.stringify({loggedIn: settings.session}));
+else {
+  const file = args[args.indexOf('--mcp-config') + 1];
+  const received = args.includes('exec') ? !!process.env.PULSE_RUNNER_MCP_CREDENTIAL?.startsWith('Bearer ') : !!JSON.parse(readFileSync(file)).mcpServers.pulse.headers.Authorization;
+  const child = settings.slow ? spawn(process.execPath, ['-e', 'setInterval(() => {}, 1000)'], {stdio:'ignore'}) : null;
+  writeFileSync(${JSON.stringify(trace)}, JSON.stringify({args, received, pid: process.pid, childPid: child?.pid}));
+  writeFileSync('job-output.txt', 'isolated output');
+  if (settings.publish) {
+    for (const argv of [['switch','-c','pul/fixture'],['add','job-output.txt'],['-c','user.name=Fixture','-c','user.email=fixture@example.invalid','commit','-m','fixture job']]) {
+      const result=spawnSync('git',argv,{encoding:'utf8'});
+      if(result.status!==0) throw new Error(result.stderr);
+    }
+  }
+  if (settings.slow) setInterval(() => {}, 1000);
+  else { console.log('Bearer fixture-secret pulse_sk_fixture'); process.exitCode = settings.fail ? 1 : 0; }
+}
+`);
+  const fakeGh = join(root,'gh.mjs');
+  await writeFile(fakeGh, `
+import { appendFileSync } from 'node:fs';
+appendFileSync(${JSON.stringify(join(root,'gh-calls.jsonl'))},JSON.stringify(process.argv.slice(2))+'\\n');
+if (process.argv.includes('view')) {console.error('no pull requests found');process.exitCode=1;}
+else console.log('https://github.com/owner/repo/pull/123');
+`);
+  process.env.PULSE_RUNNER_GH_BIN = fakeGh;
+  process.env.PULSE_RUNNER_CODEX_BIN = fake;
+  process.env.PULSE_RUNNER_CLAUDE_BIN = fake;
+  const settings = { session: true, slow: false, fail: false };
+  const updateSettings = () => writeFile(join(root, 'settings.json'), JSON.stringify(settings));
+  await updateSettings();
+  const p = await ensureDataDir();
+  await writeCredential('runner-fixture.synthetic-device');
+  await git(['init', source]);
+  await writeFile(join(source, 'source.txt'), 'original');
+  await git(['-C', source, 'add', 'source.txt']);
+  await git(['-C', source, '-c', 'user.name=Fixture', '-c', 'user.email=fixture@example.invalid', 'commit', '-m', 'initial']);
+  await git(['clone', '--mirror', source, join(p.repos, 'owner__repo.git')]);
+  const { publicKey, privateKey } = generateKeyPairSync('ed25519');
+  const config = { workspaceId: 'ws-test', runnerId: 'runner-fixture', agentId: 'agent-test', agentKind: kind, agentRole: 'dev', repos: ['owner/repo'], signingKeyId: 'fixture', signingPublicKey: publicKey.export({type:'spki',format:'pem'}).toString() };
+  const job = { id: 'rjob-test', workspaceId: config.workspaceId, runnerId: config.runnerId, agentId: config.agentId, issueId: 'issue-fixture', repoFullName: 'owner/repo', mode: 'task', issuedAt: new Date().toISOString(), expiresAt: new Date(Date.now()+60_000).toISOString(), signatureAlgorithm:'ed25519', signingKeyId: config.signingKeyId };
+  const signJob = () => { job.signature = sign(null, Buffer.from(jobPayload(job)), privateKey).toString('base64url'); };
+  signJob();
+  const calls = [];
+  const control = { cancel: false, cancelWhenRunning: false, disconnectWhenRunning: false };
+  const server = createServer(async (req, res) => {
+    let raw = ''; for await (const chunk of req) raw += chunk;
+    const body = JSON.parse(raw); calls.push({path:req.url, body});
+    res.setHeader('Content-Type', 'application/json');
+    if (req.url === '/pulseRunnerPoll') res.end(JSON.stringify({job, agent:{kind,role: job.mode === 'review' ? 'qa' : 'dev'}, mcpCredential:'pulse_sk_fixture'}));
+    else if (body.jobId && req.url === '/pulseRunnerHeartbeat') {
+      const running = await exists(trace);
+      if (control.disconnectWhenRunning && running) {res.statusCode=401;res.end('{}');}
+      else res.end(JSON.stringify({cancelRequested: control.cancel || (control.cancelWhenRunning && running)}));
+    } else res.end('{}');
+  });
+  await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
+  config.endpoint = `http://127.0.0.1:${server.address().port}`;
+  const readinessFor = () => inspectReadiness(config, (exe, args, options) => command(exe, exe === 'git' ? ['ls-remote', '--exit-code', source, 'HEAD'] : args, options));
+  const run = (extra = {}) => runOnce(config, { readinessFor, heartbeatIntervalMs: 20, ...extra });
+  try { await callback({root, source, trace, config, job, signJob, settings, updateSettings, calls, control, run}); }
+  finally {
+    server.closeAllConnections(); await new Promise(resolve => server.close(resolve));
+    for (const key of ['PULSE_RUNNER_HOME', 'PULSE_RUNNER_CODEX_BIN', 'PULSE_RUNNER_CLAUDE_BIN', 'PULSE_RUNNER_GH_BIN']) {
+      if (saved[key] === undefined) delete process.env[key]; else process.env[key] = saved[key];
+    }
+    await rm(root, {recursive:true,force:true});
+  }
+}
+
+for (const kind of ['claude','codex']) {
+  test(`integration: ${kind} executes a real fixture CLI, isolates work and cleans MCP configuration`, () => fixture(kind, async f => {
+    await f.run();
+    const trace = JSON.parse(await readFile(f.trace,'utf8'));
+    assert.equal(trace.received, true);
+    assert.ok(!trace.args.join(' ').includes('pulse_sk_fixture'));
+    assert.equal(await readFile(join(f.source,'source.txt'),'utf8'),'original');
+    assert.equal(await exists(join(paths().worktrees,f.job.id)),false);
+    assert.equal(await exists(join(paths().root,'tmp',f.job.id)),false);
+    const completion = f.calls.find(c=>c.path==='/pulseRunnerComplete').body;
+    assert.equal(completion.outcome,'completed');
+    assert.ok(!JSON.stringify(f.calls).includes('pulse_sk_fixture'));
+  }));
+  test(`integration: ${kind} missing native session rejects before creating worktrees`, () => fixture(kind, async f => {
+    f.settings.session = false; await f.updateSettings();
+    let prepared = false;
+    await assert.rejects(f.run({checkout:async()=>{prepared=true;}}),/session is unavailable/);
+    assert.equal(prepared,false);
+    assert.equal(await exists(f.trace),false);
+    assert.equal(f.calls.find(c=>c.path==='/pulseRunnerComplete').body.outcome,'failed');
+  }));
+}
+
+test('integration: invalid signed jobs never reach checkout', () => fixture('codex', async f => {
+  const original = {...f.job};
+  const cases = [
+    {signature:'invalid'}, {workspaceId:'other'}, {runnerId:'other'}, {agentId:'other'},
+    {repoFullName:'other/repo'}, {expiresAt:new Date(Date.now()-1000).toISOString()},
+    {expiresAt:'invalid'}, {issuedAt:'invalid'}, {id:'rjob-../../outside'}, {mode:'other'},
+  ];
+  for (const mutation of cases) {
+    Object.assign(f.job,original,mutation);
+    if (!mutation.signature) f.signJob();
+    let prepared=false;
+    await assert.rejects(f.run({checkout:async()=>{prepared=true;}}));
+    assert.equal(prepared,false);
+    assert.equal(await exists(f.trace),false);
+  }
+}));
+
+for (const cause of ['remote', 'signal', 'revoked']) {
+  test(`integration: ${cause} cancellation stops the CLI and descendants, skips publication and cleans worktrees`, () => fixture('codex', async f => {
+    f.settings.slow=true; await f.updateSettings();
+    f.control.cancelWhenRunning=cause==='remote';
+    f.control.disconnectWhenRunning=cause==='revoked';
+    const controller=new AbortController();
+    let published=false;
+    const running=f.run({signal:controller.signal,publish:async()=>{published=true;}});
+    if(cause==='signal') {
+      for(let i=0;i<200 && !(await exists(f.trace));i++) await new Promise(r=>setTimeout(r,10));
+      assert.equal(await exists(f.trace),true);
+      controller.abort();
+    }
+    await running;
+    const trace=JSON.parse(await readFile(f.trace,'utf8'));
+    assert.equal(published,false);
+    assert.equal(f.calls.find(c=>c.path==='/pulseRunnerComplete').body.outcome,'canceled');
+    assert.equal(await exists(join(paths().worktrees,f.job.id)),false);
+    assert.equal(await exists(join(paths().root,'tmp',f.job.id)),false);
+    assert.equal(await git(['-C',f.source,'status','--porcelain']),'');
+    for(const pid of [trace.pid,trace.childPid]) {
+      let alive=true;
+      for(let i=0;i<50 && alive;i++) {try{process.kill(pid,0);}catch{alive=false;} if(alive) await new Promise(r=>setTimeout(r,20));}
+      assert.equal(alive,false,`process ${pid} must terminate`);
+    }
+    assert.equal(f.calls.at(-1).body.status,'online');
+  }));
+}
+
+test('integration: a cancellation before execution never starts the CLI', () => fixture('claude',async f=>{
+  f.control.cancel=true;
+  await f.run();
+  assert.equal(await exists(f.trace),false);
+  assert.equal(f.calls.find(c=>c.path==='/pulseRunnerComplete').body.outcome,'canceled');
+}));
+
+test('integration: failed provider output is sanitized in reports and local logs',()=>fixture('codex',async f=>{
+  f.settings.fail=true; await f.updateSettings();
+  await f.run();
+  const completion=f.calls.find(c=>c.path==='/pulseRunnerComplete').body;
+  assert.equal(completion.outcome,'failed');
+  assert.match(completion.result,/redacted/);
+  assert.ok(!JSON.stringify(f.calls).includes('fixture-secret'));
+  const logs=await readFile(join(paths().logs,'runner.jsonl'),'utf8');
+  assert.ok(!logs.includes('pulse_sk_fixture'));
+  assert.ok(!logs.includes('fixture-secret'));
+}));
+
+test('integration: recovery prunes interrupted worktrees and temporary MCP files without touching the source',()=>fixture('codex',async f=>{
+  const mirror=join(paths().repos,'owner__repo.git');
+  const interrupted=join(paths().worktrees,'rjob-interrupted');
+  await git(['--git-dir',mirror,'worktree','add','--detach',interrupted,'HEAD']);
+  await writeFile(join(interrupted,'source.txt'),'interrupted edits');
+  const temp=join(paths().root,'tmp','rjob-interrupted');
+  await mkdir(temp,{recursive:true}); await writeFile(join(temp,'pulse-mcp.json'),'synthetic temporary data');
+  await writeFile(join(paths().root, 'active-job.json'), JSON.stringify({jobId:f.job.id}));
+  await recoverInterruptedWork(f.config);
+  assert.equal(f.calls.find(c=>c.path==='/pulseRunnerComplete').body.outcome,'canceled');
+  assert.equal(await exists(join(paths().root,'active-job.json')),false);
+  f.calls.length=0;
+  assert.equal(await exists(interrupted),false);
+  assert.equal(await exists(temp),false);
+  assert.ok(!(await git(['--git-dir',mirror,'worktree','list','--porcelain'])).includes('rjob-interrupted'));
+  assert.equal(await readFile(join(f.source,'source.txt'),'utf8'),'original');
+  await f.run();
+  assert.equal(f.calls.find(c=>c.path==='/pulseRunnerComplete').body.outcome,'completed');
+}));
+
+
+test('integration: one-shot and daemon share a lock; stale locks and thrown jobs release it',()=>fixture('codex',async()=>{
+  await withRunnerLock(async()=>{
+    await assert.rejects(withRunnerLock(async()=>{}),/already active/);
+  });
+  assert.equal(await exists(join(paths().root,'runner.lock')),false);
+  await writeFile(join(paths().root,'runner.lock'),'2147483647\n');
+  await assert.rejects(withRunnerLock(async()=>{throw new Error('fixture failure');}),/fixture failure/);
+  assert.equal(await exists(join(paths().root,'runner.lock')),false);
+  await withRunnerLock(async()=>{});
+}));
+
+test('integration: a job expires during execution and is stopped before publication',()=>fixture('claude',async f=>{
+  f.settings.slow=true; await f.updateSettings();
+  f.job.expiresAt=new Date(Date.now()+5000).toISOString(); f.signJob();
+  let published=false;
+  await f.run({publish:async()=>{published=true;}});
+  assert.equal(published,false);
+  assert.equal(f.calls.find(c=>c.path==='/pulseRunnerComplete').body.outcome,'canceled');
+  assert.equal(await exists(join(paths().worktrees,f.job.id)),false);
+}));
+
+test('integration: QA execution retains read-only flags and never publishes',()=>fixture('codex',async f=>{
+  f.job.mode='review'; f.signJob();
+  f.config.agentRole='qa';
+  let published=false;
+  await f.run({publish:async()=>{published=true;}});
+  const trace=JSON.parse(await readFile(f.trace,'utf8'));
+  assert.ok(trace.args.includes('read-only'));
+  assert.equal(published,false);
+  assert.equal(f.calls.find(c=>c.path==='/pulseRunnerComplete').body.outcome,'completed');
+}));
+
+test('integration: signed multi-repo worktrees are passed to the adapter and all cleaned',()=>fixture('codex',async f=>{
+  await git(['clone','--mirror',f.source,join(paths().repos,'owner__app.git')]);
+  f.config.repos.push('owner/app');
+  f.job.contextRepos=['owner/repo','owner/app']; f.signJob();
+  await f.run();
+  const trace=JSON.parse(await readFile(f.trace,'utf8'));
+  assert.ok(trace.args.includes('--add-dir'));
+  assert.ok(trace.args.some(arg=>arg.endsWith('owner__app')));
+  assert.equal(await exists(join(paths().worktrees,f.job.id)),false);
+  for (const repo of ['owner__repo.git','owner__app.git']) {
+    assert.ok(!(await git(['--git-dir',join(paths().repos,repo),'worktree','list','--porcelain'])).includes('rjob-test'));
+  }
+}));
+
+
+test('integration: committed job branches push to a local remote and report the fixture PR',()=>fixture('codex',async f=>{
+  f.settings.publish=true; await f.updateSettings();
+  const original=await git(['-C',f.source,'rev-parse','HEAD']);
+  await f.run();
+  const completion=f.calls.find(c=>c.path==='/pulseRunnerComplete').body;
+  assert.equal(completion.outcome,'completed');
+  assert.match(completion.result,/owner\/repo:pul\/fixture/);
+  assert.match(completion.result,/https:\/\/github.com\/owner\/repo\/pull\/123/);
+  assert.equal(await git(['-C',f.source,'rev-parse','HEAD']),original);
+  assert.notEqual(await git(['-C',f.source,'rev-parse','refs/heads/pul/fixture']),original);
+  const calls=(await readFile(join(f.root,'gh-calls.jsonl'),'utf8')).trim().split('\n').map(JSON.parse);
+  assert.equal(calls[0][1],'view'); assert.equal(calls[1][1],'create');
+  assert.equal(await exists(join(paths().worktrees,f.job.id)),false);
+}));

package/test/job.test.js

@@ -13,3 +13,26 @@ test('accepts a signed, bound job and rejects changed identity', () => {
   assert.throws(() => validateJob({ ...job, contextRepos: ['owner/repo'] }, config));
 });
 test('sanitizes provider tokens', () => assert.equal(sanitize('Bearer secret.token sk-ant-secret'), 'Bearer [redacted] [redacted]'));
+
+test('signed QA jobs require explicit agent identity and provider/role compatibility', () => {
+  const { publicKey, privateKey } = generateKeyPairSync('ed25519');
+  const job = { id: 'rjob-qa', workspaceId: 'ws-1', issueId: 'issue-1', agentId: 'qa-1', runnerId: 'runner-1', repoFullName: 'owner/repo', mode: 'review', issuedAt: new Date().toISOString(), expiresAt: new Date(Date.now() + 60000).toISOString(), signatureAlgorithm: 'ed25519', signingKeyId: 'key' };
+  job.signature = sign(null, Buffer.from(jobPayload(job)), privateKey).toString('base64url');
+  const config = { workspaceId: 'ws-1', runnerId: 'runner-1', agentId: 'dev-1', agentKind: 'codex', repos: ['owner/repo'], signingKeyId: 'key', signingPublicKey: publicKey.export({ type: 'spki', format: 'pem' }).toString() };
+  assert.throws(() => validateJob(job, config, { kind: 'codex', role: 'qa' }), /identity/);
+  config.identities = [{ agentId: 'qa-1', kind: 'codex', role: 'qa' }];
+  assert.equal(validateJob(job, config, { kind: 'codex', role: 'qa' }), true);
+  assert.throws(() => validateJob(job, config, { kind: 'claude', role: 'qa' }), /provider/);
+});
+
+test('rejects signed envelopes with missing or invalid timestamps before execution', () => {
+  const { publicKey, privateKey } = generateKeyPairSync('ed25519');
+  const config = { workspaceId: 'ws-1', agentId: 'agent-1', runnerId: 'runner-123456789012', repos: ['owner/repo'], signingKeyId: 'runner-job-v1', signingPublicKey: publicKey.export({ type: 'spki', format: 'pem' }).toString() };
+  const job = { id: 'rjob-456', workspaceId: 'ws-1', issueId: 'issue-1', agentId: 'agent-1', runnerId: 'runner-123456789012', repoFullName: 'owner/repo', mode: 'task', issuedAt: new Date().toISOString(), expiresAt: new Date(Date.now() + 60_000).toISOString(), signatureAlgorithm: 'ed25519', signingKeyId: 'runner-job-v1' };
+  const malformed = { ...job, expiresAt: 'invalid' };
+  malformed.signature = sign(null, Buffer.from(jobPayload(malformed)), privateKey).toString('base64url');
+  assert.throws(() => validateJob(malformed, config), /expired or malformed/);
+  const expired = { ...job, expiresAt: new Date(Date.now() - 1_000).toISOString() };
+  expired.signature = sign(null, Buffer.from(jobPayload(expired)), privateKey).toString('base64url');
+  assert.throws(() => validateJob(expired, config), /expired or malformed/);
+});

package/test/process.test.js

@@ -1,6 +1,6 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
-import { agentPermissionArgs } from '../src/process.js';
+import { agentPermissionArgs, mcpEndpoint } from '../src/process.js';
 
 test('QA Runner sessions use read-only filesystem permissions', () => {
   assert.deepEqual(agentPermissionArgs('codex', 'review'), ['--sandbox', 'read-only', '--ask-for-approval', 'never']);
@@ -11,3 +11,9 @@ test('development jobs retain their configured write permissions', () => {
   assert.deepEqual(agentPermissionArgs('codex', 'task'), ['--approve-for-me']);
   assert.deepEqual(agentPermissionArgs('claude', 'task'), ['--permission-mode', 'bypassPermissions', '--dangerously-skip-permissions']);
 });
+
+test('both providers use the same MCP URL for cloud and local emulator endpoints', () => {
+  assert.equal(mcpEndpoint('https://example.cloudfunctions.net'), 'https://example.cloudfunctions.net/pulseMcp');
+  assert.equal(mcpEndpoint('http://127.0.0.1:5001/demo-pulse-local/us-east4'), 'http://127.0.0.1:5001/demo-pulse-local/us-east4/pulseMcp');
+  assert.equal(mcpEndpoint('http://localhost:5001/demo-pulse-local/us-east4/pulseRunnerPoll'), 'http://localhost:5001/demo-pulse-local/us-east4/pulseMcp');
+});

package/test/readiness.test.js

@@ -0,0 +1,34 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { inspectReadiness, assertLocalReadiness } from '../src/readiness.js';
+const config = { workspaceId: 'ws-1', agentId: 'agent-1', agentKind: 'codex', repos: ['owner/repo'] };
+const job = { agentId: 'agent-1', repoFullName: 'owner/repo', mode: 'task' };
+const agent = { kind: 'codex', role: 'dev' };
+test('readiness uses native status commands and reports only booleans', async () => {
+  const calls = [];
+  const report = await inspectReadiness(config, async (cmd, args) => {
+    calls.push(args);
+    return { code: 0, output: args[0] === 'auth' ? JSON.stringify({ loggedIn: true, email: 'private', token: 'private' }) : 'private' };
+  });
+  assert.ok(calls.some((args) => args.join(' ') === 'login status'));
+  assert.ok(calls.some((args) => args.join(' ') === 'auth status'));
+  assert.equal(JSON.stringify(report).includes('private'), false);
+  assert.doesNotThrow(() => assertLocalReadiness(job, config, agent, report));
+  assert.throws(() => assertLocalReadiness({ ...job, agentId: 'other' }, config, agent, report), /identity/);
+});
+test('CLI missing, session false and Git denial remain unavailable', async () => {
+  const report = await inspectReadiness(config, async (cmd, args) => {
+    if (cmd.includes('codex')) throw new Error('missing');
+    return { code: args[0] === 'ls-remote' ? 1 : 0, output: '{"loggedIn":false}' };
+  });
+  assert.equal(report.providers.codex.cli, false);
+  assert.equal(report.providers.claude.session, false);
+  assert.equal(report.repositories[0].accessible, false);
+  assert.throws(() => assertLocalReadiness(job, config, agent, report), /CLI/);
+});
+test('QA identity is explicitly allowed and cannot execute development jobs', async () => {
+  const qaConfig = { ...config, identities: [{ agentId: 'qa-1', kind: 'claude', role: 'qa' }] };
+  const report = await inspectReadiness(qaConfig, async () => ({ code: 0, output: '{"loggedIn":true}' }));
+  assert.doesNotThrow(() => assertLocalReadiness({ ...job, agentId: 'qa-1', mode: 'review' }, qaConfig, { kind: 'claude', role: 'qa' }, report));
+  assert.throws(() => assertLocalReadiness({ ...job, agentId: 'qa-1' }, qaConfig, { kind: 'claude', role: 'qa' }, report), /role/);
+});

package/test/runtime.test.js

@@ -0,0 +1,42 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { command, providerInvocation } from '../src/process.js';
+import { addIsolatedWorktree, removeIsolatedWorktree } from '../src/worktree.js';
+
+test('cancellation terminates the active child process', async () => {
+  const controller = new AbortController();
+  const running = command(process.execPath, ['-e', 'setTimeout(() => {}, 30000)'], { signal: controller.signal });
+  setTimeout(() => controller.abort(), 100);
+  const result = await running;
+  assert.notEqual(result.code, 0);
+});
+
+test('Claude and Codex adapters receive only ephemeral MCP configuration references', () => {
+  const config = { endpoint: 'https://pulse.example.test' };
+  const codex = providerInvocation('codex', '/tmp/job', [], config, '/tmp/pulse-mcp.json', 'run task');
+  const claude = providerInvocation('claude', '/tmp/job', [], config, '/tmp/pulse-mcp.json', 'run task');
+  assert.match(codex.args.join(' '), /env_http_headers/);
+  assert.doesNotMatch(codex.args.join(' '), /secret|credential-value/);
+  assert.ok(claude.args.includes('/tmp/pulse-mcp.json'));
+  assert.throws(() => providerInvocation('unknown', '/tmp/job', [], config, '', 'run task'), /Unsupported agent kind/);
+});
+
+test('an isolated worktree can change and clean up without changing its source checkout', async () => {
+  const root = await mkdtemp(join(tmpdir(), 'pulse-runner-worktree-'));
+  const repo = join(root, 'repo');
+  const worktree = join(root, 'job');
+  try {
+    await command('git', ['init', repo]);
+    await writeFile(join(repo, 'source.txt'), 'original\n');
+    await command('git', ['-C', repo, 'add', 'source.txt']);
+    await command('git', ['-C', repo, '-c', 'user.name=Pulse Test', '-c', 'user.email=pulse@example.invalid', 'commit', '-m', 'initial']);
+    const checkout = await addIsolatedWorktree('owner/repo', join(repo, '.git'), worktree);
+    assert.ok(checkout.baseCommit);
+    await writeFile(join(worktree, 'source.txt'), 'changed in job\n');
+    assert.equal(await readFile(join(repo, 'source.txt'), 'utf8'), 'original\n');
+    await removeIsolatedWorktree(checkout);
+  } finally { await rm(root, { recursive: true, force: true }); }
+});

package/test/service.test.js

@@ -0,0 +1,49 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, readFile, readdir, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { service } from '../src/service.js';
+
+for (const platform of ['darwin','linux','win32']) {
+  test(`service: ${platform} retains instance home and supports install, stop, start and uninstall`,async()=>{
+    const root=await mkdtemp(join(tmpdir(),'pulse-service-'));
+    const saved=process.env.PULSE_RUNNER_HOME;
+    process.env.PULSE_RUNNER_HOME=join(root,'instance home');
+    const calls=[];
+    const options={platform,userHome:join(root,'os-user'),print:()=>{},command:async(exe,args)=>{calls.push({exe,args});return {code:0,output:''};}};
+    try {
+      await service('install',options);
+      if(platform==='darwin') {
+        const folder=join(options.userHome,'Library','LaunchAgents');
+        const [file]=await readdir(folder);const plist=await readFile(join(folder,file),'utf8');
+        assert.match(plist,/<string>--home<\/string>/);
+        assert.ok(plist.includes(process.env.PULSE_RUNNER_HOME));
+        assert.match(file,/com\.pulse\.runner\.[0-9a-f]{12}\.plist/);
+      } else if(platform==='linux') {
+        const folder=join(options.userHome,'.config','systemd','user');
+        const [file]=await readdir(folder);const unit=await readFile(join(folder,file),'utf8');
+        const homeArgument=unit.match(/--home ("(?:\\.|[^"])*")/)?.[1];
+        assert.equal(JSON.parse(homeArgument),process.env.PULSE_RUNNER_HOME);
+        assert.match(file,/pulse-runner-[0-9a-f]{12}\.service/);
+      } else {
+        const install=calls.find(c=>c.args.includes('/Create'));
+        assert.ok(install.args.some(arg=>arg.includes(`--home "${process.env.PULSE_RUNNER_HOME}"`)));
+        assert.ok(install.args.some(arg=>/^PulseRunner-[0-9a-f]{12}$/.test(arg)));
+      }
+      await service('stop',options);
+      const afterStop=calls.length;
+      await service('start',options);
+      if(platform==='darwin') assert.deepEqual(calls.slice(afterStop).map(c=>c.args[0]),['bootstrap','kickstart']);
+      await service('uninstall',options);
+      const firstName=calls.find(c=>c.args.some(arg=>/pulse\.runner\.|pulse-runner-|PulseRunner-/.test(arg))).args.join(' ');
+      process.env.PULSE_RUNNER_HOME=join(root,'second instance');
+      calls.length=0; await service('install',options);
+      const secondName=calls.find(c=>c.args.some(arg=>/pulse\.runner\.|pulse-runner-|PulseRunner-/.test(arg))).args.join(' ');
+      assert.notEqual(firstName,secondName);
+    } finally {
+      if(saved===undefined) delete process.env.PULSE_RUNNER_HOME;else process.env.PULSE_RUNNER_HOME=saved;
+      await rm(root,{recursive:true,force:true});
+    }
+  });
+}