@newsails/veil-cli 1.0.1

package/test/integration/01-health.test.js

@@ -0,0 +1,25 @@
+'use strict';
+
+// ── Test 1: Health & Status endpoints ────────────────────────────────────────
+
+await test('GET /health returns 200 with status ok', async () => {
+  const res = await client.health();
+  assert.strictEqual(res.status, 200, `Expected 200, got ${res.status}: ${JSON.stringify(res.body)}`);
+  assert.strictEqual(res.body.status, 'ok');
+  assert(res.body.version, 'version missing');
+  assert(typeof res.body.uptime === 'number', 'uptime should be a number');
+});
+
+await test('GET /status returns server info', async () => {
+  const res = await client.status();
+  assert.strictEqual(res.status, 200);
+  assert.strictEqual(res.body.status, 'ok');
+  assert(typeof res.body.agents === 'number', 'agents count missing');
+  assert(typeof res.body.activeSessions === 'number');
+  assert(typeof res.body.pendingTasks === 'number');
+});
+
+await test('GET /nonexistent returns 404', async () => {
+  const res = await fetch('http://localhost:5050/nonexistent-route-xyz');
+  assert.strictEqual(res.status, 404, `Expected 404, got ${res.status}`);
+});

package/test/integration/02-agents.test.js

@@ -0,0 +1,80 @@
+'use strict';
+
+// ── Test 2: Agent management endpoints ───────────────────────────────────────
+
+await test('GET /agents returns array with expected agents', async () => {
+  const res = await client.agents.list();
+  assert.strictEqual(res.status, 200, `Expected 200, got ${res.status}: ${JSON.stringify(res.body)}`);
+  assert(Array.isArray(res.body.agents), 'agents should be an array');
+  const names = res.body.agents.map(a => a.name);
+  assert(names.includes('hello'), `hello agent missing — found: ${names.join(', ')}`);
+  assert(names.includes('assistant'), `assistant agent missing`);
+  assert(names.includes('coder'), `coder agent missing`);
+  assert(names.includes('writer'), `writer agent missing`);
+  assert(names.includes('analyst'), `analyst agent missing`);
+});
+
+await test('GET /agents/:name returns agent details for hello', async () => {
+  const res = await client.agents.get('hello');
+  assert.strictEqual(res.status, 200, `Expected 200, got ${res.status}: ${JSON.stringify(res.body)}`);
+  assert.strictEqual(res.body.agent.name, 'hello');
+  assert(res.body.agent.model, 'model should be set');
+  assert(res.body.agent.modes, 'modes should be present');
+});
+
+await test('GET /agents/:name returns 404 for unknown agent', async () => {
+  const res = await client.agents.get('does-not-exist-xyz');
+  assert.strictEqual(res.status, 404, `Expected 404, got ${res.status}`);
+  assert(res.body.error, 'error body missing');
+  assert.strictEqual(res.body.error.code, 'AGENT_NOT_FOUND');
+});
+
+await test('GET /agents/coder has task mode enabled', async () => {
+  const res = await client.agents.get('coder');
+  assert.strictEqual(res.status, 200);
+  assert(res.body.agent.modes?.task?.enabled, 'coder should have task mode enabled');
+});
+
+await test('GET /agents/hello has chat mode enabled', async () => {
+  const res = await client.agents.get('hello');
+  assert.strictEqual(res.status, 200);
+  assert(res.body.agent.modes?.chat?.enabled, 'hello should have chat mode enabled');
+});
+
+await test('GET /agents/:name/sessions returns sessions scoped to agent', async () => {
+  const res = await fetch('http://localhost:5050/agents/hello/sessions');
+  assert.strictEqual(res.status, 200);
+  const body = await res.json();
+  assert.strictEqual(body.agentName, 'hello');
+  assert(Array.isArray(body.sessions), 'sessions should be array');
+  body.sessions.forEach(s => {
+    assert.strictEqual(s.agent_name, 'hello', `all sessions should belong to hello, got: ${s.agent_name}`);
+  });
+});
+
+await test('GET /agents/:name/tasks returns tasks scoped to agent', async () => {
+  const res = await fetch('http://localhost:5050/agents/hello/tasks');
+  assert.strictEqual(res.status, 200);
+  const body = await res.json();
+  assert.strictEqual(body.agentName, 'hello');
+  assert(Array.isArray(body.tasks), 'tasks should be array');
+  body.tasks.forEach(t => {
+    assert.strictEqual(t.agent_name, 'hello', `all tasks should belong to hello, got: ${t.agent_name}`);
+  });
+});
+
+await test('GET /agents/:name/skills returns skills listing', async () => {
+  const res = await fetch('http://localhost:5050/agents/hello/skills');
+  assert.strictEqual(res.status, 200);
+  const body = await res.json();
+  assert.strictEqual(body.agentName, 'hello');
+  assert(Array.isArray(body.skills), 'skills should be array');
+  assert(Array.isArray(body.customTools), 'customTools should be array');
+});
+
+await test('GET /agents/:name/skills returns 404 for unknown agent', async () => {
+  const res = await fetch('http://localhost:5050/agents/does-not-exist-xyz/skills');
+  assert.strictEqual(res.status, 404);
+  const body = await res.json();
+  assert.strictEqual(body.error.code, 'AGENT_NOT_FOUND');
+});

package/test/integration/03-chat-hello.test.js

@@ -0,0 +1,48 @@
+'use strict';
+
+// ── Test 3: Basic chat with hello agent (no tools) ───────────────────────────
+
+await test('POST /agents/hello/chat returns a response', async () => {
+  const res = await client.chat.send('hello', 'Say exactly: HELLO_TEST_OK');
+  assert.strictEqual(res.status, 200, `Expected 200, got ${res.status}: ${JSON.stringify(res.body)}`);
+  assert(res.body.sessionId, 'sessionId missing');
+  assert(res.body.message, 'message missing');
+  assert.strictEqual(res.body.message.role, 'assistant');
+  assert(res.body.message.content, 'content missing');
+  assert(res.body.message.content.length > 0, 'content is empty');
+});
+
+await test('Chat response contains non-empty text', async () => {
+  const res = await client.chat.send('hello', 'What is 2 + 2? Reply with just the number.');
+  assert.strictEqual(res.status, 200, JSON.stringify(res.body));
+  const content = res.body.message.content;
+  assert(content.includes('4'), `Expected answer to contain "4", got: ${content}`);
+});
+
+await test('Chat with hello agent returns sessionId', async () => {
+  const res = await client.chat.send('hello', 'Hello!');
+  assert.strictEqual(res.status, 200);
+  const { sessionId } = res.body;
+  assert(sessionId, 'sessionId missing');
+  assert(sessionId.startsWith('sess_'), `sessionId should start with sess_, got: ${sessionId}`);
+});
+
+await test('Chat with unknown agent returns 404', async () => {
+  const res = await client.chat.send('nonexistent-agent-xyz', 'Hello');
+  assert.strictEqual(res.status, 404);
+  assert.strictEqual(res.body.error.code, 'AGENT_NOT_FOUND');
+});
+
+await test('Chat with empty message returns 400', async () => {
+  const res = await client.chat.send('hello', '');
+  assert.strictEqual(res.status, 400);
+  assert.strictEqual(res.body.error.code, 'VALIDATION_ERROR');
+});
+
+await test('Chat returns tokenUsage object', async () => {
+  const res = await client.chat.send('hello', 'Ping!');
+  assert.strictEqual(res.status, 200);
+  assert(res.body.tokenUsage, 'tokenUsage missing');
+  assert(typeof res.body.tokenUsage.input === 'number', 'tokenUsage.input should be a number');
+  assert(typeof res.body.tokenUsage.output === 'number', 'tokenUsage.output should be a number');
+});

package/test/integration/04-chat-multiturn.test.js

@@ -0,0 +1,61 @@
+'use strict';
+
+// ── Test 4: Multi-turn chat (session continuity) ──────────────────────────────
+
+await test('Multi-turn chat: second message continues same session', async () => {
+  // Turn 1
+  const res1 = await client.chat.send('hello', 'My name is TestUser42. Remember it.');
+  assert.strictEqual(res1.status, 200, JSON.stringify(res1.body));
+  const { sessionId } = res1.body;
+  assert(sessionId, 'sessionId missing');
+
+  // Turn 2 — same session
+  const res2 = await client.chat.send('hello', 'What is my name?', sessionId);
+  assert.strictEqual(res2.status, 200, JSON.stringify(res2.body));
+  assert.strictEqual(res2.body.sessionId, sessionId, 'sessionId should match');
+  const content = res2.body.message.content;
+  assert(
+    content.toLowerCase().includes('testuser42') || content.includes('TestUser42'),
+    `Expected agent to remember name "TestUser42", got: ${content}`
+  );
+});
+
+await test('Multi-turn chat: session messages are stored and retrievable', async () => {
+  // Start a session
+  const res1 = await client.chat.send('hello', 'Count to three: one, two, three.');
+  assert.strictEqual(res1.status, 200);
+  const { sessionId } = res1.body;
+
+  // Get session messages
+  const msgsRes = await client.sessions.messages(sessionId);
+  assert.strictEqual(msgsRes.status, 200, JSON.stringify(msgsRes.body));
+  assert(Array.isArray(msgsRes.body.messages), 'messages should be array');
+  assert(msgsRes.body.messages.length >= 3, `Expected ≥3 messages (system+user+assistant), got: ${msgsRes.body.messages.length}`);
+
+  const roles = msgsRes.body.messages.map(m => m.role);
+  assert(roles.includes('system'), 'system message missing');
+  assert(roles.includes('user'), 'user message missing');
+  assert(roles.includes('assistant'), 'assistant message missing');
+});
+
+await test('Multi-turn chat: using closed session returns 400', async () => {
+  // Create a session
+  const res1 = await client.chat.send('hello', 'Hi');
+  const { sessionId } = res1.body;
+
+  // Close it
+  await client.sessions.list(); // ensure sessions endpoint works
+  const delRes = await fetch(`http://localhost:5050/sessions/${sessionId}`, { method: 'DELETE' });
+  assert.strictEqual(delRes.status, 200);
+
+  // Try to use it
+  const res2 = await client.chat.send('hello', 'Hello again', sessionId);
+  assert.strictEqual(res2.status, 400, `Expected 400 for closed session, got: ${res2.status}`);
+  assert.strictEqual(res2.body.error.code, 'SESSION_CLOSED');
+});
+
+await test('Sessions list endpoint works', async () => {
+  const res = await client.sessions.list();
+  assert.strictEqual(res.status, 200);
+  assert(Array.isArray(res.body.sessions), 'sessions should be array');
+});

package/test/integration/05-chat-writer.test.js

@@ -0,0 +1,48 @@
+'use strict';
+
+// ── Test 5: Writer agent chat (creative content generation) ───────────────────
+
+await test('Writer agent: generates a short poem on demand', async () => {
+  const res = await client.chat.send('writer', 'Write a 4-line poem about a curious robot.');
+  assert.strictEqual(res.status, 200, JSON.stringify(res.body));
+  const content = res.body.message.content;
+  assert(content.length > 50, `Expected a poem (>50 chars), got: ${content}`);
+  // A poem should have line breaks
+  assert(content.includes('\n'), `Expected line breaks in poem, got: ${content}`);
+});
+
+await test('Writer agent: writes a short story opening', async () => {
+  const res = await client.chat.send('writer', 'Write a 3-sentence opening for a sci-fi story set on Mars.');
+  assert.strictEqual(res.status, 200, JSON.stringify(res.body));
+  const content = res.body.message.content;
+  assert(content.length > 100, `Expected story opening (>100 chars), got: ${content}`);
+});
+
+await test('Writer agent: summarizes a text', async () => {
+  const res = await client.chat.send('writer',
+    'Summarize this in one sentence: "The quick brown fox jumps over the lazy dog. This pangram has been used for decades to test typewriters and fonts because it contains every letter of the English alphabet."'
+  );
+  assert.strictEqual(res.status, 200, JSON.stringify(res.body));
+  const content = res.body.message.content;
+  assert(content.length > 20, 'Summary too short');
+  assert(content.length < 500, 'Summary too long — should be one sentence');
+});
+
+await test('Writer agent: task mode produces document output', async () => {
+  const res = await client.tasks.create('writer',
+    'Write a short README for a fictional CLI tool called "quickfetch" that downloads URLs. Keep it under 200 words.'
+  );
+  assert.strictEqual(res.status, 202, `Expected 202, got ${res.status}: ${JSON.stringify(res.body)}`);
+  const { taskId } = res.body;
+  assert(taskId, 'taskId missing');
+
+  const task = await client.pollTask(taskId, { timeout: 90000 });
+  assert.strictEqual(task.status, 'finished', `Task failed: ${task.error}`);
+  assert(task.output, 'output missing');
+  assert(task.output.length > 100, 'README too short');
+  // Should mention the tool name
+  assert(
+    task.output.toLowerCase().includes('quickfetch'),
+    `README should mention quickfetch, got: ${task.output.slice(0, 200)}`
+  );
+}, { slow: true });

package/test/integration/06-task-basic.test.js

@@ -0,0 +1,68 @@
+'use strict';
+
+// ── Test 6: Task mode basics (hello agent — no tools) ─────────────────────────
+
+await test('Task create returns 202 with taskId', async () => {
+  const res = await client.tasks.create('hello', 'What is the capital of France? Reply in one word.');
+  assert.strictEqual(res.status, 202, `Expected 202, got ${res.status}: ${JSON.stringify(res.body)}`);
+  assert(res.body.taskId, 'taskId missing');
+  assert.strictEqual(res.body.status, 'pending');
+  assert(res.body.taskId.startsWith('task_'), `taskId should start with task_, got: ${res.body.taskId}`);
+});
+
+await test('Task completes with expected output', async () => {
+  const res = await client.tasks.create('hello', 'What is the capital of France? Reply in one word.');
+  const task = await client.pollTask(res.body.taskId, { timeout: 60000 });
+  assert.strictEqual(task.status, 'finished', `Expected finished, got ${task.status}: ${task.error}`);
+  assert(task.output, 'output missing');
+  assert(
+    task.output.toLowerCase().includes('paris'),
+    `Expected "Paris" in output, got: ${task.output}`
+  );
+}, { slow: true });
+
+await test('GET /tasks/:id returns task details', async () => {
+  const createRes = await client.tasks.create('hello', 'Say the word: TASK_GET_TEST');
+  const { taskId } = createRes.body;
+
+  // Poll completion
+  const task = await client.pollTask(taskId, { timeout: 60000 });
+
+  // Now fetch by ID
+  const getRes = await client.tasks.get(taskId);
+  assert.strictEqual(getRes.status, 200, JSON.stringify(getRes.body));
+  assert.strictEqual(getRes.body.task.id, taskId);
+  assert(getRes.body.task.agent_name === 'hello', `agent_name should be hello, got: ${getRes.body.task.agent_name}`);
+  assert(['finished', 'failed'].includes(getRes.body.task.status));
+}, { slow: true });
+
+await test('GET /tasks/:id returns 404 for unknown task', async () => {
+  const res = await client.tasks.get('task_nonexistent_xyz_123');
+  assert.strictEqual(res.status, 404);
+  assert.strictEqual(res.body.error.code, 'TASK_NOT_FOUND');
+});
+
+await test('GET /tasks returns list', async () => {
+  const res = await client.tasks.list();
+  assert.strictEqual(res.status, 200);
+  assert(Array.isArray(res.body.tasks), 'tasks should be array');
+});
+
+await test('Task events are recorded', async () => {
+  const createRes = await client.tasks.create('hello', 'Say: EVENTS_TEST_OK');
+  const { taskId } = createRes.body;
+  await client.pollTask(taskId, { timeout: 60000 });
+
+  const eventsRes = await client.tasks.events(taskId);
+  assert.strictEqual(eventsRes.status, 200);
+  assert(Array.isArray(eventsRes.body.events), 'events should be array');
+  assert(eventsRes.body.events.length > 0, 'should have at least one event');
+  const types = eventsRes.body.events.map(e => e.type);
+  assert(types.some(t => t.includes('iteration') || t.includes('status')), `Expected iteration/status events, got: ${types.join(', ')}`);
+}, { slow: true });
+
+await test('Task create with unknown agent returns 404', async () => {
+  const res = await client.tasks.create('agent-does-not-exist-xyz', 'Do something');
+  assert.strictEqual(res.status, 404);
+  assert.strictEqual(res.body.error.code, 'AGENT_NOT_FOUND');
+});

package/test/integration/07-task-tools.test.js

@@ -0,0 +1,74 @@
+'use strict';
+
+// ── Test 7: Task mode with tools (assistant agent) ────────────────────────────
+
+const path = require('path');
+const PROJECT_ROOT = path.join(__dirname, '../..');
+
+await test('Assistant task: list a directory', async () => {
+  const res = await client.tasks.create('assistant',
+    `List the files in the directory: ${PROJECT_ROOT}/test. Report back the filenames you see.`
+  );
+  assert.strictEqual(res.status, 202, JSON.stringify(res.body));
+  const task = await client.pollTask(res.body.taskId, { timeout: 90000 });
+  assert.strictEqual(task.status, 'finished', `Task failed: ${task.error}`);
+  assert(task.output, 'output missing');
+  // Should mention runner.js or client.js
+  assert(
+    task.output.includes('runner.js') || task.output.includes('client.js') || task.output.includes('integration'),
+    `Expected file listing to mention runner.js/client.js/integration, got: ${task.output.slice(0, 500)}`
+  );
+}, { slow: true });
+
+await test('Assistant task: read a specific file', async () => {
+  const res = await client.tasks.create('assistant',
+    `Read the file at ${PROJECT_ROOT}/package.json and tell me the "name" field value.`
+  );
+  assert.strictEqual(res.status, 202, JSON.stringify(res.body));
+  const task = await client.pollTask(res.body.taskId, { timeout: 90000 });
+  assert.strictEqual(task.status, 'finished', `Task failed: ${task.error}`);
+  assert(task.output, 'output missing');
+  assert(
+    task.output.includes('veilcli'),
+    `Expected name "veilcli" in output, got: ${task.output.slice(0, 500)}`
+  );
+}, { slow: true });
+
+await test('Assistant task: write and verify a file', async () => {
+  const testFile = `${PROJECT_ROOT}/test/results/write-test-${Date.now()}.txt`;
+  const res = await client.tasks.create('assistant',
+    `Create a file at "${testFile}" with content: "WRITE_TEST_SUCCESS". Then confirm it was written.`
+  );
+  assert.strictEqual(res.status, 202, JSON.stringify(res.body));
+  const task = await client.pollTask(res.body.taskId, { timeout: 90000 });
+  assert.strictEqual(task.status, 'finished', `Task failed: ${task.error}`);
+
+  // Verify the file was actually created
+  const fs = require('fs');
+  try {
+    const written = fs.existsSync(testFile);
+    assert(written, `File was not created at ${testFile}`);
+    if (written) fs.unlinkSync(testFile); // cleanup
+  } catch (e) {
+    // File might be in a different location — just check output mentions success
+    assert(
+      task.output.toLowerCase().includes('success') ||
+      task.output.toLowerCase().includes('written') ||
+      task.output.toLowerCase().includes('created'),
+      `Expected success confirmation in output, got: ${task.output.slice(0, 500)}`
+    );
+  }
+}, { slow: true });
+
+await test('Assistant task: grep for a pattern in files', async () => {
+  const res = await client.tasks.create('assistant',
+    `Search for the word "runner" in files under ${PROJECT_ROOT}/test. Tell me which files contain it and on what lines.`
+  );
+  assert.strictEqual(res.status, 202, JSON.stringify(res.body));
+  const task = await client.pollTask(res.body.taskId, { timeout: 90000 });
+  assert.strictEqual(task.status, 'finished', `Task failed: ${task.error}`);
+  assert(
+    task.output.includes('runner') || task.output.includes('runner.js'),
+    `Expected mention of runner.js in output, got: ${task.output.slice(0, 500)}`
+  );
+}, { slow: true });

package/test/integration/08-task-code-analysis.test.js

@@ -0,0 +1,69 @@
+'use strict';
+
+// ── Test 8: Coder agent — read-only code analysis ─────────────────────────────
+
+const path = require('path');
+const PROJECT_ROOT = path.join(__dirname, '../..');
+
+await test('Coder: analyze package.json and identify dependencies', async () => {
+  const res = await client.tasks.create('coder',
+    `Read ${PROJECT_ROOT}/package.json and list all the production dependencies and their versions.`
+  );
+  assert.strictEqual(res.status, 202, JSON.stringify(res.body));
+  const task = await client.pollTask(res.body.taskId, { timeout: 120000 });
+  assert.strictEqual(task.status, 'finished', `Task failed: ${task.error}`);
+  assert(task.output, 'output missing');
+  // Should mention known deps
+  assert(
+    task.output.includes('express') || task.output.includes('better-sqlite3') || task.output.includes('ajv'),
+    `Expected known dependencies in output, got: ${task.output.slice(0, 500)}`
+  );
+}, { slow: true });
+
+await test('Coder: explain what a specific file does', async () => {
+  const res = await client.tasks.create('coder',
+    `Read ${PROJECT_ROOT}/utils/id.js and explain in 2-3 sentences what it does and how it generates IDs.`
+  );
+  assert.strictEqual(res.status, 202, JSON.stringify(res.body));
+  const task = await client.pollTask(res.body.taskId, { timeout: 120000 });
+  assert.strictEqual(task.status, 'finished', `Task failed: ${task.error}`);
+  assert(task.output, 'output missing');
+  assert(
+    task.output.toLowerCase().includes('crypto') || task.output.toLowerCase().includes('random') || task.output.toLowerCase().includes('id'),
+    `Expected explanation mentioning crypto/random/id, got: ${task.output.slice(0, 500)}`
+  );
+}, { slow: true });
+
+await test('Coder: list project structure', async () => {
+  const res = await client.tasks.create('coder',
+    `List the top-level files and folders in ${PROJECT_ROOT}. Give me a brief description of each.`
+  );
+  assert.strictEqual(res.status, 202, JSON.stringify(res.body));
+  const task = await client.pollTask(res.body.taskId, { timeout: 120000 });
+  assert.strictEqual(task.status, 'finished', `Task failed: ${task.error}`);
+  assert(task.output, 'output missing');
+  // Should mention key directories
+  assert(
+    task.output.includes('tools') || task.output.includes('core') || task.output.includes('cli'),
+    `Expected project structure mentions, got: ${task.output.slice(0, 500)}`
+  );
+}, { slow: true });
+
+await test('Coder: bash tool is denied (read-only agent)', async () => {
+  const res = await client.tasks.create('coder',
+    `Try to run the bash command "echo BASH_TEST" and report whether it worked.`
+  );
+  assert.strictEqual(res.status, 202, JSON.stringify(res.body));
+  const task = await client.pollTask(res.body.taskId, { timeout: 60000 });
+  // Task should still finish (agent handles denial gracefully), but bash should be blocked
+  assert(['finished', 'failed'].includes(task.status));
+  if (task.status === 'finished') {
+    // The agent should report it couldn't run bash or it was denied
+    const output = (task.output || '').toLowerCase();
+    assert(
+      output.includes('deny') || output.includes('permission') || output.includes('not') ||
+      output.includes('cannot') || output.includes("don't") || output.includes('unable') || !output.includes('bash_test'),
+      `Expected bash to be denied, but output might show success: ${task.output?.slice(0, 300)}`
+    );
+  }
+}, { slow: true });

package/test/integration/09-memory-analyst.test.js

@@ -0,0 +1,63 @@
+'use strict';
+
+// ── Test 9: Analyst agent — memory + todo tools in task mode ──────────────────
+
+const path = require('path');
+const PROJECT_ROOT = path.join(__dirname, '../..');
+
+await test('Analyst: uses todo_write and reads a directory', async () => {
+  const res = await client.tasks.create('analyst',
+    `Quick task: use todo_write to create a 2-item checklist ("list tools dir", "report findings"), then use list_dir to list ${PROJECT_ROOT}/tools and report the filenames. Keep it brief.`
+  );
+  assert.strictEqual(res.status, 202, JSON.stringify(res.body));
+  // Give extra buffer: agent maxDurationSeconds=180, so poll at 240s
+  const task = await client.pollTask(res.body.taskId, { timeout: 240000 });
+  assert(['finished', 'failed'].includes(task.status), `Unexpected status: ${task.status}`);
+  if (task.status === 'finished') {
+    assert(task.output, 'output missing');
+    assert(
+      task.output.includes('bash') || task.output.includes('read_file') || task.output.includes('grep') || task.output.includes('.js'),
+      `Expected tool files listed, got: ${task.output.slice(0, 500)}`
+    );
+  }
+}, { slow: true });
+
+await test('Analyst: uses memory_write to save findings', async () => {
+  const res = await client.tasks.create('analyst',
+    `Read ${PROJECT_ROOT}/package.json and ${PROJECT_ROOT}/README.md (if it exists). Use memory_write to save key facts about this project (name, version, purpose). Then summarize what you saved.`
+  );
+  assert.strictEqual(res.status, 202, JSON.stringify(res.body));
+  const task = await client.pollTask(res.body.taskId, { timeout: 120000 });
+  // Task should succeed and report what was saved
+  assert(['finished', 'failed'].includes(task.status));
+  if (task.status === 'finished') {
+    assert(task.output, 'output missing');
+    // Should mention the package name or memory
+    assert(
+      task.output.includes('veil') || task.output.includes('memory') || task.output.includes('saved') || task.output.includes('Veil'),
+      `Expected memory save mention, got: ${task.output.slice(0, 500)}`
+    );
+  }
+}, { slow: true });
+
+await test('Analyst: full project analysis produces comprehensive report', async () => {
+  const res = await client.tasks.create('analyst',
+    `Perform a complete analysis of the project at ${PROJECT_ROOT}. Steps:
+1. List top-level files and folders
+2. Read package.json to identify the project
+3. Read at least 3 source files from core/ or utils/
+4. Use grep to find how many JS files the project has
+5. Write a structured report covering: what the project does, its architecture, key dependencies, and notable patterns.`
+  );
+  assert.strictEqual(res.status, 202, JSON.stringify(res.body));
+  const task = await client.pollTask(res.body.taskId, { timeout: 180000 });
+  assert.strictEqual(task.status, 'finished', `Task failed: ${task.error}`);
+  assert(task.output, 'output missing');
+  // Comprehensive report should be long
+  assert(task.output.length > 300, `Report too short (${task.output.length} chars): ${task.output.slice(0, 200)}`);
+  // Should mention key aspects
+  assert(
+    task.output.toLowerCase().includes('agent') || task.output.toLowerCase().includes('veil'),
+    `Expected "agent" or "veil" in report, got: ${task.output.slice(0, 300)}`
+  );
+}, { slow: true });

package/test/integration/10-task-advanced.test.js

@@ -0,0 +1,85 @@
+'use strict';
+
+// ── Test 10: Advanced task operations ─────────────────────────────────────────
+
+await test('Task cancellation works', async () => {
+  // Create a task, immediately cancel it before it can finish
+  const res = await client.tasks.create('hello',
+    'Count very slowly from 1 to 1000, saying each number with a pause.'
+  );
+  assert.strictEqual(res.status, 202);
+  const { taskId } = res.body;
+
+  // Give it a moment to start, then cancel
+  await new Promise(r => setTimeout(r, 500));
+  const cancelRes = await client.tasks.cancel(taskId);
+  assert.strictEqual(cancelRes.status, 200, JSON.stringify(cancelRes.body));
+  assert.strictEqual(cancelRes.body.status, 'canceled');
+
+  // Verify final state
+  const getRes = await client.tasks.get(taskId);
+  assert(['canceled', 'finished'].includes(getRes.body.task.status),
+    `Expected canceled or finished (if it finished first), got: ${getRes.body.task.status}`);
+});
+
+await test('Multiple concurrent tasks run independently', async () => {
+  // Launch 3 tasks simultaneously
+  const [r1, r2, r3] = await Promise.all([
+    client.tasks.create('hello', 'What is 10 + 5? Reply with just the number.'),
+    client.tasks.create('hello', 'What is 20 + 3? Reply with just the number.'),
+    client.tasks.create('hello', 'What is 7 + 8? Reply with just the number.'),
+  ]);
+
+  assert.strictEqual(r1.status, 202);
+  assert.strictEqual(r2.status, 202);
+  assert.strictEqual(r3.status, 202);
+
+  // All different task IDs
+  const ids = [r1.body.taskId, r2.body.taskId, r3.body.taskId];
+  assert.strictEqual(new Set(ids).size, 3, 'All taskIds should be unique');
+
+  // Poll all to completion
+  const [t1, t2, t3] = await Promise.all([
+    client.pollTask(r1.body.taskId, { timeout: 90000 }),
+    client.pollTask(r2.body.taskId, { timeout: 90000 }),
+    client.pollTask(r3.body.taskId, { timeout: 90000 }),
+  ]);
+
+  assert.strictEqual(t1.status, 'finished', `Task 1 failed: ${t1.error}`);
+  assert.strictEqual(t2.status, 'finished', `Task 2 failed: ${t2.error}`);
+  assert.strictEqual(t3.status, 'finished', `Task 3 failed: ${t3.error}`);
+
+  assert(String(t1.output || '').includes('15'), `Task 1: expected 15 in output, got: ${t1.output}`);
+  assert(String(t2.output || '').includes('23'), `Task 2: expected 23 in output, got: ${t2.output}`);
+  assert(String(t3.output || '').includes('15'), `Task 3: expected 15 in output, got: ${t3.output}`);
+}, { slow: true });
+
+await test('Task list filtering by agent works', async () => {
+  // Create a task for hello agent
+  await client.tasks.create('hello', 'Say: FILTER_TEST');
+  // Give it a moment
+  await new Promise(r => setTimeout(r, 300));
+
+  const res = await client.tasks.list({ agentName: 'hello', limit: 5 });
+  assert.strictEqual(res.status, 200);
+  const allHello = res.body.tasks.every(t => t.agent_name === 'hello');
+  assert(allHello, 'All tasks should be from hello agent');
+});
+
+await test('Task list filtering by status works', async () => {
+  const res = await client.tasks.list({ status: 'finished', limit: 10 });
+  assert.strictEqual(res.status, 200);
+  const allFinished = res.body.tasks.every(t => t.status === 'finished');
+  assert(allFinished, 'All returned tasks should be finished');
+});
+
+await test('Task respond returns 400 when task is not waiting', async () => {
+  // Create a task that completes quickly
+  const createRes = await client.tasks.create('hello', 'Say: RESPOND_TEST');
+  const task = await client.pollTask(createRes.body.taskId, { timeout: 60000 });
+
+  // Try to respond to a finished task
+  const respondRes = await client.tasks.respond(task.id, 'Some response');
+  assert.strictEqual(respondRes.status, 400);
+  assert.strictEqual(respondRes.body.error.code, 'TASK_NOT_WAITING');
+}, { slow: true });