@logicseek/hello-cc 1.0.1 → 1.0.2

package/scripts/dsh-cordis-acceptance.mjs

@@ -0,0 +1,200 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import http from 'node:http';
+import { randomUUID, createHash } from 'node:crypto';
+import { createRequire } from 'node:module';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { DatabaseSync } from 'node:sqlite';
+import { JsonRpcProcess } from '../lib/integrations/native/jsonrpc.mjs';
+import { createDshEnvironment, ensureDshIntegration } from '../lib/integrations/dsh.mjs';
+import { checkDshRuntime } from '../lib/integrations/dsh-cordis.mjs';
+import { redactSecrets } from '../lib/shared/redact.mjs';
+
+// Runs the published Harness, AgentLoop, tool policies and persistence. Default:
+// a deterministic local Messages model. --run-live uses the original DeepSeek
+// route from environment, without writing/copying credentials or user config.
+const install = process.argv[2];
+if (!install) throw new Error('Usage: node scripts/dsh-cordis-acceptance.mjs /isolated/dsh/install [--run-live] [--bundle]');
+const live = process.argv.includes('--run-live');
+const bundle = process.argv.includes('--bundle');
+if (live && !process.env.DEEPSEEK_API_KEY) throw new Error('Live acceptance requires an existing DEEPSEEK_API_KEY');
+const requireOfficial = createRequire(path.join(path.resolve(install), 'package.json'));
+const binary = requireOfficial.resolve('@deepseek-ai/dsh/lib/bin.js');
+checkDshRuntime(binary);
+const repo = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const sandbox = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'hcc-dsh-cordis-acceptance-')));
+const rootA = path.join(sandbox, 'project A'), rootB = path.join(sandbox, 'project B');
+const home = path.join(sandbox, 'home');
+for (const dir of [rootA, rootB, home]) fs.mkdirSync(dir, { mode: 0o700 });
+const env = createDshEnvironment(process.env);
+Object.assign(env, { HOME: home, DSH_HOME: path.join(home, 'dsh'), DSH_TELEMETRY_DISABLED: '1',
+  PATH: path.dirname(process.execPath) + path.delimiter + (env.PATH || '') });
+const marker = 'CORDIS_' + randomUUID().replaceAll('-', '').slice(0, 16);
+const receipt = { startedAt: new Date().toISOString(), baseline: '0.2.0-rc.2', node: process.version,
+  loading: bundle ? 'npm tarball installed into isolated ACP profile' : 'project overlay',
+  validation: live ? 'original authenticated DeepSeek model' : 'deterministic local Messages model; real official Harness',
+  sandbox, checks: [], cleanup: {}, sourceHashes: {} };
+for (const name of ['lib/integrations/dsh-cordis.mjs', 'lib/integrations/dsh-collaboration.mjs',
+  'lib/mcp/tools.mjs', 'lib/integrations/native/jsonrpc.mjs', 'scripts/dsh-cordis-acceptance.mjs']) {
+  receipt.sourceHashes[name] = createHash('sha256').update(fs.readFileSync(path.join(repo, name))).digest('hex');
+}
+const output = path.join(sandbox, 'receipt.json');
+function check(name, details = {}) { receipt.checks.push({ name, passed: true, ...details }); }
+function read(root, sql, ...params) {
+  const db = new DatabaseSync(path.join(root, '.hello-cc', 'mesh.db'));
+  try { return db.prepare(sql).all(...params).map(row => ({ ...row })); } finally { db.close(); }
+}
+function hcc(root, args) {
+  const result = spawnSync(process.execPath, [path.join(repo, 'bin/hcc.mjs'), '--root', root, '--json', ...args],
+    { cwd: root, env, encoding: 'utf8', timeout: 15000 });
+  assert.equal(result.status, 0, redactSecrets(result.stderr + result.stdout));
+  const value = JSON.parse(result.stdout); return value.data ?? value;
+}
+let rpc, server;
+const modelRequests = [], notices = [], permissions = [];
+let taskId, peerA;
+let stage = 0;
+function stream(res, model, block) {
+  res.writeHead(200, { 'content-type': 'text/event-stream' });
+  const event = (type, value) => res.write(`event: ${type}\ndata: ${JSON.stringify({ type, ...value })}\n\n`);
+  event('message_start', { message: { id: 'msg-' + randomUUID(), type: 'message', role: 'assistant', model,
+    content: [], stop_reason: null, stop_sequence: null, usage: { input_tokens: 1, output_tokens: 0 } } });
+  event('content_block_start', { index: 0, content_block: block.type === 'tool_use' ? { ...block, input: {} } : block });
+  if (block.type === 'tool_use') event('content_block_delta', { index: 0, delta: { type: 'input_json_delta', partial_json: JSON.stringify(block.input) } });
+  event('content_block_stop', { index: 0 });
+  event('message_delta', { delta: { stop_reason: block.type === 'tool_use' ? 'tool_use' : 'end_turn', stop_sequence: null }, usage: { output_tokens: 1 } });
+  event('message_stop', {}); res.end();
+}
+try {
+  const setup = ensureDshIntegration({ root: rootA, cwd: rootA }, { mode: 'cordis' });
+  const policy = path.join(sandbox, 'policy.mjs');
+  fs.writeFileSync(policy, `export const inject = ['tools'];\nexport function apply(ctx) {\n  ctx.on('tools/pre-execute', async (exec, next) => {\n    if (exec.name === 'hcc_message_send' && exec.arguments.body === 'DENY_WRITE') return {kind:'deny',reason:'acceptance denies this write'};\n    if (exec.name === 'hcc_message_send' && exec.arguments.body === 'ASK_WRITE') return {kind:'ask',reason:'acceptance requires approval'};\n    return next();\n  });\n}\n`);
+  const policyPatch = path.join(sandbox, 'policy.yml');
+  fs.writeFileSync(policyPatch, `- insert:\n    - id: acceptance-policy\n      name: ${JSON.stringify(policy)}\n`);
+  const argv = ['--profile', 'acp', ...(bundle ? [] : ['--patch', setup.patchPath]), '--patch', policyPatch];
+  if (bundle) {
+    const packed = spawnSync('npm', ['pack', '--ignore-scripts', '--json', '--pack-destination', sandbox],
+      { cwd: repo, env, encoding: 'utf8', timeout: 30000 });
+    assert.equal(packed.status, 0, packed.stderr);
+    const metadata = JSON.parse(packed.stdout)[0];
+    assert.ok(metadata.files.some(file => file.path === 'lib/integrations/dsh.bundle.yml'));
+    assert.ok(metadata.files.some(file => file.path === 'lib/integrations/dsh-cordis.d.ts'));
+    const unpack = path.join(sandbox, 'installed'); fs.mkdirSync(unpack);
+    const extracted = spawnSync('tar', ['-xzf', path.join(sandbox, metadata.filename), '-C', unpack],
+      { env, encoding: 'utf8', timeout: 10000 });
+    assert.equal(extracted.status, 0, extracted.stderr);
+    const profile = path.join(env.DSH_HOME, 'profiles', 'acp');
+    const packageDirectory = path.join(profile, 'node_modules', '@logicseek');
+    fs.mkdirSync(packageDirectory, { recursive: true, mode: 0o700 });
+    fs.symlinkSync(path.join(unpack, 'package'), path.join(packageDirectory, 'hello-cc'));
+    fs.writeFileSync(path.join(profile, 'package.json'), JSON.stringify({ name: 'isolated-cordis-profile', private: true,
+      dependencies: { '@logicseek/hello-cc': 'file:' + path.join(unpack, 'package') },
+      dsh: { profile: { bundles: ['@deepseek-ai/dsh-base', '@deepseek-ai/dsh-acp-app', '@logicseek/hello-cc'] } } }));
+    fs.writeFileSync(path.join(profile, 'cordis.yml'), '[]\n');
+    receipt.package = { filename: metadata.filename, shasum: metadata.shasum, fileCount: metadata.files.length };
+  }
+
+  if (!live) {
+    server = http.createServer(async (req, res) => {
+      try {
+        const chunks = []; for await (const chunk of req) chunks.push(chunk);
+        const body = JSON.parse(Buffer.concat(chunks).toString());
+        modelRequests.push(body);
+        const serialized = JSON.stringify(body.messages);
+        const primary = serialized.includes('RUN_COLLABORATION_A');
+        const actions = [
+          ['hcc_state', {}], ['hcc_task_next', {}], ['hcc_lock_acquire', { resource: 'cordis-proof.txt', task_id: taskId }],
+          ['hcc_message_send', { to: 'acceptance-coordinator', body: marker, task_id: taskId }],
+          ['hcc_handoff', { task_id: taskId, summary: marker, to: 'acceptance-coordinator', tests: ['official Harness tool round trip'] }],
+          ['hcc_message_send', { to: 'acceptance-coordinator', body: 'DENY_WRITE' }],
+          ['hcc_message_send', { to: 'acceptance-coordinator', body: 'ASK_WRITE' }]
+        ];
+        const action = primary ? actions[stage++] : null;
+        if (action) {
+          assert.ok(body.tools.some(tool => tool.name === action[0]), 'model must receive the registered collaboration tool');
+          stream(res, body.model, { type: 'tool_use', id: 'tool-' + randomUUID(), name: action[0], input: action[1] });
+        } else stream(res, body.model, { type: 'text', text: primary ? marker : 'B_SESSION_OK' });
+      } catch (error) { res.writeHead(500); res.end(JSON.stringify({ error: { type: 'api_error', message: error.message } })); }
+    });
+    await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
+    env.DEEPSEEK_API_KEY = 'isolated-local-model';
+    env.DEEPSEEK_BASE_URL = `http://127.0.0.1:${server.address().port}`;
+  }
+  rpc = new JsonRpcProcess({ binary, args: argv, cwd: rootA, env, timeoutMs: 180000,
+    onNotification: (method, params) => { if (method === 'session/update') notices.push(params); },
+    onRequest: (method, params) => {
+      if (method !== 'session/request_permission') throw new Error(`Unexpected server request ${method}`);
+      permissions.push({ method, requested: true });
+      const rejected = params.options.find(option => option.kind === 'reject_once');
+      return rejected ? { outcome: { outcome: 'selected', optionId: rejected.optionId } } : { outcome: { outcome: 'cancelled' } };
+    }
+  });
+  await rpc.start();
+  const initialized = await rpc.request('initialize', { protocolVersion: 1, clientCapabilities: {}, clientInfo: { name: 'hello-cc-cordis-acceptance', version: '1.0.1' } });
+  assert.equal(initialized.protocolVersion, 1);
+  const a = await rpc.request('session/new', { cwd: rootA, mcpServers: [] });
+  const b = await rpc.request('session/new', { cwd: rootB, mcpServers: [] });
+  assert.notEqual(a.sessionId, b.sessionId);
+  peerA = read(rootA, 'SELECT peer FROM peer_bindings WHERE provider_session_id=?', a.sessionId)[0].peer;
+  const peerB = read(rootB, 'SELECT peer FROM peer_bindings WHERE provider_session_id=?', b.sessionId)[0].peer;
+  check('two Agents in one official runtime have independent project, peer and raw session bindings', { peerA, peerB });
+  hcc(rootA, ['register', '--peer', 'acceptance-coordinator', '--kind', 'shell']);
+  hcc(rootA, ['task', 'create', '--from', 'acceptance-coordinator', '--title', marker]);
+  taskId = read(rootA, 'SELECT id FROM tasks WHERE title=?', marker)[0].id;
+  hcc(rootA, ['msg', 'send', '--from', 'acceptance-coordinator', '--to', peerA, '--body', 'INBOX_ONLY_FOR_A_' + marker]);
+  const promptA = `RUN_COLLABORATION_A. This is an isolated acceptance task. Use hcc_state, then hcc_task_next to claim task #${taskId}. Acquire the lock cordis-proof.txt for that task using hcc_lock_acquire. Send the exact body ${marker} to acceptance-coordinator using hcc_message_send, with task_id ${taskId}. Record a hcc_handoff for that task to acceptance-coordinator, with summary ${marker}. Then call hcc_message_send once with body DENY_WRITE and once with body ASK_WRITE to acceptance-coordinator to test refusal handling. Respect both refusals; do not retry or bypass them. Finally reply only ${marker}. Do not use Bash, files, other tools or delegate.`;
+  const completed = await rpc.request('session/prompt', { sessionId: a.sessionId, prompt: [{ type: 'text', text: promptA }] }, { timeoutMs: 180000 });
+  assert.equal(completed.stopReason, 'end_turn');
+  const task = read(rootA, 'SELECT * FROM tasks WHERE id=?', taskId)[0];
+  assert.equal(task.owner, peerA);
+  const locks = read(rootA, 'SELECT owner, task_id FROM locks WHERE resource=? OR base_resource=?', 'cordis-proof.txt', 'cordis-proof.txt');
+  assert.ok(locks.length, 'The model must acquire the requested resource, including a scoped lock key');
+  assert.equal(locks[0].owner, peerA);
+  assert.equal(locks[0].task_id, taskId);
+  assert.equal(read(rootA, 'SELECT sender FROM messages WHERE body=?', marker)[0].sender, peerA);
+  assert.ok(read(rootA, 'SELECT * FROM handoffs WHERE task_id=?', taskId).length);
+  check('model commits task claim, scoped lock, peer message and handoff through shared collaboration services', { taskId });
+  assert.equal(read(rootA, "SELECT * FROM messages WHERE body IN ('DENY_WRITE', 'ASK_WRITE')").length, 0);
+  assert.ok(permissions.length >= 1, 'ask must reach the ACP permission handler');
+  check('deny and ask policy remain effective, rejected writes do not execute', { permissionRequests: permissions.length });
+  assert.ok(read(rootA, 'SELECT * FROM message_reads WHERE peer=?', peerA).length);
+  assert.equal(read(rootB, 'SELECT * FROM messages').length, 0);
+  const promptB = 'RUN_SESSION_B. Use hcc_state to read your own project. Do not use any other tools. Reply only B_SESSION_OK.';
+  await rpc.request('session/prompt', { sessionId: b.sessionId, prompt: [{ type: 'text', text: promptB }] }, { timeoutMs: 180000 });
+  check('committed context ACKs only its Agent inbox; other project remains isolated');
+  if (!live) {
+    assert.match(JSON.stringify(modelRequests[0].messages), new RegExp('INBOX_ONLY_FOR_A_' + marker));
+    const requestsB = modelRequests.filter(body => JSON.stringify(body.messages).includes('RUN_SESSION_B'));
+    assert.ok(requestsB.length);
+    for (const body of requestsB) assert.doesNotMatch(JSON.stringify(body.messages), new RegExp(marker));
+    check('actual first model request contains awaited collaboration context, foreign Agent context never appears');
+  }
+  await rpc.request('session/close', { sessionId: a.sessionId });
+  assert.equal(read(rootA, 'SELECT status FROM peers WHERE id=?', peerA)[0].status, 'exited');
+  assert.equal(read(rootB, 'SELECT status FROM peers WHERE id=?', peerB)[0].status, 'idle');
+  await rpc.request('session/prompt', { sessionId: b.sessionId, prompt: [{ type: 'text', text: promptB }] }, { timeoutMs: 180000 });
+  check('closing one Agent preserves the live sibling and marks only its own peer exited');
+  await rpc.request('session/resume', { sessionId: a.sessionId, cwd: rootA, mcpServers: [] });
+  assert.equal(read(rootA, 'SELECT provider_session_id FROM peer_bindings WHERE peer=?', peerA)[0].provider_session_id, a.sessionId);
+  check('resume re-establishes the original raw session and peer without duplicate live ownership');
+  await rpc.request('session/close', { sessionId: a.sessionId });
+  await rpc.request('session/close', { sessionId: b.sessionId });
+  receipt.passed = true;
+} catch (error) {
+  receipt.passed = false;
+  receipt.error = { name: error.name, message: redactSecrets(error.message) };
+  process.exitCode = 1;
+} finally {
+  try { await rpc?.close(); receipt.cleanup.ownedRuntimeStopped = true; } catch { receipt.cleanup.ownedRuntimeStopped = false; process.exitCode = 1; }
+  if (server) { server.closeAllConnections(); await new Promise(resolve => server.close(resolve)); }
+  receipt.cleanup.localModelStopped = !server?.listening;
+  receipt.modelRequests = live ? null : modelRequests.length;
+  receipt.permissionRequests = permissions.length;
+  receipt.updateKinds = [...new Set(notices.map(value => value.update?.sessionUpdate).filter(Boolean))];
+  receipt.completedAt = new Date().toISOString();
+  fs.writeFileSync(output, JSON.stringify(redactSecrets(receipt), null, 2) + '\n', { mode: 0o600 });
+  console.log(JSON.stringify({ receipt: output, ...redactSecrets(receipt) }, null, 2));
+}

package/scripts/dsh-installed-acceptance.mjs

@@ -0,0 +1,247 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { createHash, randomUUID } from 'node:crypto';
+import { createRequire } from 'node:module';
+import { spawn } from 'node:child_process';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { DatabaseSync } from 'node:sqlite';
+import { setTimeout as delay } from 'node:timers/promises';
+import { JsonRpcProcess } from '../lib/integrations/native/jsonrpc.mjs';
+import { createDshEnvironment } from '../lib/integrations/dsh.mjs';
+import { checkDshRuntime } from '../lib/integrations/dsh-cordis.mjs';
+import { redactSecrets } from '../lib/shared/redact.mjs';
+
+// Uses actual npm/pnpm installations and the installed public CLI. Every
+// profile, project and process belongs to this run. Real inference is opt-in.
+const args = process.argv.slice(2);
+const install = args[0];
+const opt = (name, fallback) => { const i = args.indexOf(name); return i < 0 ? fallback : args[i + 1]; };
+if (!install || install === '--help') {
+  console.log('Usage: node scripts/dsh-installed-acceptance.mjs /isolated/dsh/install [--run-live] [--tarball PATH] [--output-dir DIR] [--npm-cache DIR] [--pnpm-store DIR]');
+  process.exit(0);
+}
+const live = args.includes('--run-live');
+if (live && !process.env.DEEPSEEK_API_KEY) throw new Error('Live acceptance requires the existing DEEPSEEK_API_KEY');
+const repo = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const resolveOfficial = createRequire(path.join(path.resolve(install), 'package.json'));
+const binary = resolveOfficial.resolve('@deepseek-ai/dsh/lib/bin.js');
+checkDshRuntime(binary);
+const directory = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'hcc-dsh-installed-')));
+fs.chmodSync(directory, 0o700);
+const home = path.join(directory, 'home'), root = path.join(directory, 'project'), cordisRoot = path.join(directory, 'cordis-project');
+for (const dir of [home, root, cordisRoot]) fs.mkdirSync(dir, { mode: 0o700 });
+const prefix = path.join(directory, 'npm-install');
+const env = createDshEnvironment(process.env);
+Object.assign(env, { HOME: home, DSH_HOME: path.join(home, 'dsh'), DSH_TELEMETRY_DISABLED: '1',
+  PATH: [path.dirname(process.execPath), path.join(path.resolve(install), 'node_modules/.bin'), path.join(prefix, 'node_modules/.bin'), env.PATH || ''].join(path.delimiter) });
+const noModelEnv = { ...env, DEEPSEEK_API_KEY: 'isolated-no-model-placeholder' };
+const output = path.resolve(opt('--output-dir', directory));
+fs.mkdirSync(output, { recursive: true });
+const receiptPath = path.join(output, 'dsh-installed-receipt.json');
+const receipt = { startedAt: new Date().toISOString(), node: process.version, baseline: '0.2.0-rc.2', directory,
+  validation: live ? 'installed public CLI, original authenticated DeepSeek model' : 'installed public CLI and official profile lifecycle; no model call',
+  checks: [], artifacts: {}, cleanup: {}, limitations: ['No npm publication, global installation, employee device or genuine business task acceptance.'] };
+function check(name, data = {}) { receipt.checks.push({ name, passed: true, ...data }); flush(); console.log(JSON.stringify({ check: name, ...data })); }
+function flush() { fs.writeFileSync(receiptPath, JSON.stringify(redactSecrets(receipt), null, 2) + '\n', { mode: 0o600 }); }
+async function run(label, executable, argv, { cwd = directory, childEnv = env, timeout = 120000, omitOutput = false, allowFailure = false } = {}) {
+  const ownsProcessGroup = process.platform !== 'win32';
+  const child = spawn(executable, argv, { cwd, env: childEnv, detached: ownsProcessGroup, stdio: ['ignore', 'pipe', 'pipe'] });
+  const stop = signal => {
+    try { if (ownsProcessGroup) process.kill(-child.pid, signal); else child.kill(signal); }
+    catch (error) { if (error.code !== 'ESRCH') throw error; }
+  };
+  let stdout = '', stderr = '', timeoutReached = false;
+  const timer = setTimeout(() => { timeoutReached = true; stop('SIGTERM'); }, timeout);
+  const forced = setTimeout(() => { if (timeoutReached) stop('SIGKILL'); }, timeout + 5000);
+  const progress = setInterval(() => console.log(JSON.stringify({ running: label })), 20000);
+  child.stdout.on('data', bytes => { stdout = (stdout + bytes).slice(-2000000); });
+  child.stderr.on('data', bytes => { stderr = (stderr + bytes).slice(-2000000); });
+  try {
+    const status = await new Promise((resolve, reject) => { child.once('error', reject); child.once('close', (code, signal) => resolve({ code, signal })); });
+    fs.writeFileSync(path.join(directory, label + '.log'), omitOutput ? `exit=${status.code}; output omitted\n` : redactSecrets(stdout + stderr), { mode: 0o600 });
+    if (!allowFailure) assert.equal(status.code, 0, `${label} failed (${status.signal || status.code}): ${redactSecrets(stderr).slice(-2000)}`);
+    return { ...status, stdout, stderr };
+  } finally { clearTimeout(timer); clearTimeout(forced); clearInterval(progress); }
+}
+const hash = file => createHash('sha256').update(fs.readFileSync(file)).digest('hex');
+function read(project, sql, ...params) {
+  const db = new DatabaseSync(path.join(project, '.hello-cc/mesh.db'), { readOnly: true });
+  try { return db.prepare(sql).all(...params).map(row => ({ ...row })); } finally { db.close(); }
+}
+let cli, api, rpc, nativeUp = false;
+const peer = 'installed-dsh', marker = 'INSTALLED_' + randomUUID().replaceAll('-', '').slice(0, 16);
+const denyTarget = path.join(root, 'permission-denied.txt');
+async function hcc(argv, project = root) {
+  const result = await run('hcc-' + argv.slice(0, 2).join('-'), process.execPath, [cli, '--root', project, '--json', ...argv], { cwd: project, timeout: 30000 });
+  const parsed = JSON.parse(result.stdout); return parsed.data ?? parsed;
+}
+async function until(fn, label, timeout = 120000) {
+  const deadline = Date.now() + timeout; let notice = Date.now() + 20000;
+  while (Date.now() < deadline) { const value = await fn(); if (value) return value;
+    if (Date.now() > notice) { console.log(JSON.stringify({ waiting: label })); notice += 20000; } await delay(250); }
+  throw new Error('Timed out: ' + label);
+}
+async function send(body, task) { return hcc(['native', 'send', '--peer', peer, '--from', 'acceptance-coordinator', '--body', body, ...(task ? ['--task', String(task)] : [])]); }
+async function finish(message, { decline = false, label = 'native turn' } = {}) {
+  return until(async () => {
+    const pending = await hcc(['native', 'requests', '--peer', peer]);
+    for (const request of pending.filter(item => item.status === 'pending')) {
+      const serialized = JSON.stringify(request.params || request);
+      if (decline) assert.ok(serialized.includes(denyTarget), 'The refused ACP request must name the test-owned target file');
+      else assert.ok(serialized.includes(root) || /hcc_|hello_cc_scoped/.test(serialized), 'Only acceptance-owned file or collaboration operations may be approved');
+      const decision = decline ? 'decline' : 'accept';
+      await hcc(['native', 'respond', '--peer', peer, '--request', String(request.requestId), '--decision', decision]);
+      receipt.approvals ||= []; receipt.approvals.push({ method: request.method, decision, requestId: request.requestId, turnId: request.turnId, ...(decline ? { target: denyTarget } : {}) });
+    }
+    const deliveries = await hcc(['native', 'deliveries', '--peer', peer]);
+    const row = (Array.isArray(deliveries) ? deliveries : deliveries.deliveries).find(item => item.message_id === message.message_id);
+    if (!row || !['completed', 'failed', 'unknown'].includes(row.state)) return false;
+    assert.equal(row.state, 'completed', JSON.stringify(row));
+    const replies = read(root, 'SELECT body FROM messages WHERE reply_to=?', message.message_id);
+    assert.equal(replies.length, 1); assert.equal(read(root, 'SELECT * FROM message_reads WHERE peer=? AND message_id=?', peer, message.message_id).length, 1);
+    return { row, reply: replies[0].body };
+  }, label, 180000);
+}
+try {
+  let tarball = opt('--tarball');
+  if (!tarball) {
+    const packed = await run('npm-pack', 'npm', ['pack', '--ignore-scripts', '--json', '--pack-destination', directory], { cwd: repo });
+    const meta = JSON.parse(packed.stdout)[0]; tarball = path.join(directory, meta.filename);
+    receipt.package = { filename: meta.filename, fileCount: meta.files.length, shasum: meta.shasum };
+  }
+  tarball = fs.realpathSync(tarball);
+  receipt.package = { ...receipt.package, filename: path.basename(tarball), sha256: hash(tarball) };
+  const candidate = path.join(output, path.basename(tarball));
+  if (candidate !== tarball) fs.copyFileSync(tarball, candidate);
+  receipt.artifacts.tarball = candidate;
+  receipt.platform = { os: process.platform, architecture: process.arch };
+  receipt.officialLauncher = binary;
+  receipt.packageInstallPrefix = prefix;
+  await run('npm-install', 'npm', ['install', '--prefix', prefix, '--cache', path.resolve(opt('--npm-cache', path.join(directory, 'npm-cache'))), '--no-audit', '--no-fund', tarball], { childEnv: noModelEnv, timeout: 240000 });
+  const pkgDir = path.join(prefix, 'node_modules/@logicseek/hello-cc');
+  cli = path.join(pkgDir, 'bin/hcc.mjs');
+  const requireInstalled = createRequire(path.join(pkgDir, 'package.json'));
+  const pty = requireInstalled('node-pty');
+  const terminal = pty.spawn('/bin/sh', ['-c', 'printf INSTALLED_PTY_READY'], { cwd: root, env: noModelEnv, name: 'xterm', cols: 80, rows: 24 });
+  let ptyText = ''; terminal.onData(text => { ptyText += text; });
+  await new Promise(resolve => terminal.onExit(resolve)); assert.match(ptyText, /INSTALLED_PTY_READY/);
+  check('fresh npm package installation and installed Node 24 PTY dependency load');
+  const sourceFiles = ['bin/hcc.mjs','lib/cli/commands/dsh.mjs','lib/cli/commands/native.mjs','lib/integrations/dsh.mjs','lib/integrations/dsh-cordis.mjs','lib/integrations/dsh-collaboration.mjs','lib/integrations/dsh.bundle.yml','lib/integrations/native/dsh-acp.mjs','lib/integrations/native/jsonrpc.mjs','lib/runtime/native/service.mjs','lib/runtime/native/client.mjs','lib/mcp/tools.mjs'];
+  receipt.installedSourceHashes = Object.fromEntries(sourceFiles.map(file => [file, hash(path.join(pkgDir, file))]));
+  for (const file of sourceFiles) assert.equal(hash(path.join(repo, file)), receipt.installedSourceHashes[file], 'Installed runtime must match current source: ' + file);
+  check('installed Cordis, ACP, MCP and native service match current source hashes');
+  await run('installed-cli-help', process.execPath, [cli, 'dsh', '--help'], { childEnv: noModelEnv });
+  await hcc(['dsh', 'setup', '--mode', 'cordis']);
+  const firstConfig = hash(path.join(root, '.hello-cc/dsh/cordis.patch.yml'));
+  await hcc(['dsh', 'setup']); assert.equal(hash(path.join(root, '.hello-cc/dsh/cordis.patch.yml')), firstConfig);
+  const dshStatus = await hcc(['dsh', 'status']); assert.equal(dshStatus.mode, 'cordis');
+  check('installed CLI setup is idempotent; default PATH resolves the pinned official dsh launcher');
+
+  const profile = 'hcc-cordis-acceptance';
+  await run('profile-init', process.execPath, [binary, '--profile', profile, '--from-default-profile', 'acp', '--dump-config'], { childEnv: noModelEnv, omitOutput: true });
+  const profileDir = path.join(env.DSH_HOME, 'profiles', profile);
+  const overlay = path.join(profileDir, 'cordis.patch.yml');
+  if (!fs.existsSync(overlay)) fs.writeFileSync(overlay, '[]\n');
+  fs.appendFileSync(overlay, '\n# acceptance-owned override must survive package management\n');
+  const overlayHash = hash(overlay);
+  const manifest = () => JSON.parse(fs.readFileSync(path.join(profileDir, 'package.json')));
+  // Pin the only native build required by this candidate in the private profile.
+  fs.appendFileSync(path.join(profileDir, 'pnpm-workspace.yaml'), '\nallowBuilds:\n  node-pty@1.2.0-beta.15: true\n');
+  receipt.approvedBuilds = ['node-pty@1.2.0-beta.15'];
+  const pnpmStore = path.resolve(opt('--pnpm-store', path.join(directory, 'pnpm-store')));
+  for (let i = 0; i < 2; i++) await run('plugin-add-' + i, process.execPath, [binary, 'plugin', '--profile', profile, 'add', tarball, '--store-dir', pnpmStore], { childEnv: noModelEnv, timeout: 900000 });
+  assert.equal(manifest().dsh.profile.bundles.filter(name => name === '@logicseek/hello-cc').length, 1);
+  assert.equal(hash(overlay), overlayHash);
+  const config = await run('installed-profile-config', process.execPath, [binary, '--profile', profile, '--dump-config'], { childEnv: noModelEnv, omitOutput: true });
+  assert.match(config.stdout, /dsh-cordis\.mjs/);
+  check('official plugin add and repeated add install one Cordis bundle and preserve profile overrides');
+  rpc = new JsonRpcProcess({ binary, args: ['--profile', profile], cwd: cordisRoot, env: live ? env : noModelEnv, timeoutMs: 30000 });
+  await rpc.start();
+  await rpc.request('initialize', { protocolVersion: 1, clientCapabilities: {}, clientInfo: { name: 'hcc-installed-acceptance', version: '1.0.1' } });
+  const session = await rpc.request('session/new', { cwd: cordisRoot, mcpServers: [] });
+  const binding = read(cordisRoot, 'SELECT * FROM peer_bindings WHERE provider_session_id=?', session.sessionId)[0];
+  assert.equal(binding.transport, 'cordis');
+  if (live) {
+    await rpc.request('session/prompt', { sessionId: session.sessionId, prompt: [{ type: 'text', text: `Use hcc_state, then hcc_message_send once to acceptance-coordinator with exact body ${marker}. Reply only ${marker}. Do not use other tools or files.` }] }, { timeoutMs: 180000 });
+    assert.equal(read(cordisRoot, 'SELECT sender FROM messages WHERE body=?', marker)[0].sender, binding.peer);
+    check('officially installed Cordis bundle performs a real model collaboration tool round trip');
+  }
+  await rpc.request('session/close', { sessionId: session.sessionId });
+  await rpc.close(); rpc = null;
+  check('officially installed bundle creates and disposes a real Agent without duplicate ownership');
+  const beforeRemovalHash = hash(overlay);
+  receipt.profileOverlayHashes = { beforeAdd: overlayHash, beforeRemove: beforeRemovalHash };
+  await run('plugin-remove', process.execPath, [binary, 'plugin', '--profile', profile, 'remove', '@logicseek/hello-cc', '--store-dir', pnpmStore], { childEnv: noModelEnv, timeout: 900000 });
+  assert.ok(!manifest().dsh.profile.bundles.includes('@logicseek/hello-cc'));
+  assert.equal(hash(overlay), beforeRemovalHash);
+  receipt.profileOverlayHashes.afterRemove = hash(overlay);
+  await run('profile-after-remove', process.execPath, [binary, '--profile', profile, '--dump-config'], { childEnv: noModelEnv, omitOutput: true });
+  check('official plugin remove removes bundle metadata and preserves other profile configuration');
+
+  const acpProfile = path.join(env.DSH_HOME, 'profiles/acp');
+  await run('native-profile-init', process.execPath, [binary, '--profile', 'acp', '--dump-config'], { childEnv: noModelEnv, omitOutput: true });
+  const policy = path.join(directory, 'approval-policy.mjs');
+  fs.writeFileSync(policy, `export const inject=['tools'];\nexport function apply(ctx){ctx.on('tools/pre-execute',async(exec,next)=>{const args=exec.arguments||{};if((['write','str_replace_editor'].includes(exec.name)&&[args.file_path,args.path].includes(${JSON.stringify(denyTarget)}))||(exec.name==='bash'&&String(args.command||'').includes(${JSON.stringify(denyTarget)})))return {kind:'ask',reason:'acceptance requires explicit approval for this test-owned write'};return next();});}\n`);
+  fs.writeFileSync(path.join(acpProfile, 'cordis.patch.yml'), `- insert:\n    - id: installed-approval-policy\n      name: ${JSON.stringify(policy)}\n`);
+  // The project overlay is not loaded by native ACP. Only the approval policy
+  // enters its private profile; Cordis/hooks never duplicate the native owner.
+  const nativeClient = await import(pathToFileURL(path.join(pkgDir, 'lib/runtime/native/client.mjs')));
+  const ctx = { root, dbPath: path.join(root, '.hello-cc/mesh.db') };
+  api = (method, route, body) => nativeClient.nativeRequest(ctx, method, route, body);
+  await hcc(['native', 'up']); nativeUp = true;
+  const started = await hcc(['native', 'start', '--peer', peer, '--provider', 'dsh']);
+  assert.equal(started.provider, 'dsh'); assert.ok(started.sessionId); assert.ok(started.capabilities.approvals);
+  receipt.nativeSessionId = started.sessionId;
+  check('installed public native CLI starts the default dsh ACP adapter and scoped MCP without factory injection');
+  if (live) {
+    const permission = await send(`Use the write tool once with file_path ${denyTarget} and content PROOF. This is a permission refusal test. If refused, do not retry or bypass the refusal; reply only DENIED. Do not read or modify anything else.`);
+    await finish(permission, { decline: true, label: 'installed real native approval refusal' });
+    assert.ok(receipt.approvals?.some(item => item.decision === 'decline' && item.method === 'session/request_permission'));
+    assert.equal(fs.existsSync(denyTarget), false);
+    check('installed native CLI receives a real ACP file approval, declines it, and the file remains absent');
+    fs.writeFileSync(path.join(root, 'orders.json'), JSON.stringify([{ sku:'A',quantity:3,unit_price:12.5 },{ sku:'B',quantity:2,unit_price:8 },{ sku:'A',quantity:1,unit_price:12.5 }]));
+    const task = await hcc(['task','create','--from','acceptance-coordinator','--title','Summarize isolated order fixture']);
+    const reportFile = path.join(root, 'order-summary.json');
+    const work = await send(`This is an isolated order-report task #${task.id}. Use the hello_cc_scoped MCP hcc_task_next to claim it and hcc_lock_acquire for order-summary.json with task_id ${task.id}. Read only orders.json. Compute total quantity and revenue from the input records, aggregate quantity and revenue per SKU, and write ${reportFile} as a JSON object with keys total_quantity,total_revenue,by_sku (by_sku maps SKU to {quantity,revenue}). Use native read/write tools. Send the exact body ${marker} to acceptance-coordinator using MCP hcc_message_send with task_id ${task.id}. Record a local hcc_result_record with task_id ${task.id}, title "Order fixture report", status passed, evidence ["${reportFile}"]; record hcc_handoff to acceptance-coordinator with the same evidence in changed_files. Release your order-summary.json lock. Do not use any other files, external requests or delegation. Reply only ${marker}.`, task.id);
+    const finished = await finish(work, { label:'installed native scoped MCP task and file workflow' });
+    assert.match(finished.reply, new RegExp(marker));
+    const actual = JSON.parse(fs.readFileSync(reportFile));
+    assert.deepEqual(actual, {total_quantity:6,total_revenue:66,by_sku:{A:{quantity:4,revenue:50},B:{quantity:2,revenue:16}}});
+    const taskRow = read(root, 'SELECT * FROM tasks WHERE id=?', task.id)[0]; assert.equal(taskRow.owner, peer);
+    assert.equal(read(root,'SELECT * FROM messages WHERE sender=? AND recipient=? AND body=? AND reply_to IS NULL',peer,'acceptance-coordinator',marker).length,1);
+    assert.ok(read(root,'SELECT * FROM handoffs WHERE task_id=? AND from_peer=?',task.id,peer).length);
+    assert.ok(read(root,"SELECT * FROM events WHERE type='task.result.recorded' AND task_id=? AND actor=?",task.id,peer).length);
+    assert.equal(read(root,'SELECT * FROM locks WHERE owner=? AND task_id=?',peer,task.id).length,0);
+    const completion = await send(`The coordinator independently verified order-summary.json: quantity 6, revenue 66 and correct per-SKU totals. Finish your owned task #${task.id} using your session-specific hcc CLI command: task done --peer ${peer} --id ${task.id} --summary ${marker}. Use only that hcc task command; no other tools or file changes. Reply only ${marker}.`);
+    await finish(completion, { label:'installed task completion after independent artifact verification' });
+    assert.equal(read(root,'SELECT status FROM tasks WHERE id=?',task.id)[0].status,'done');
+    const reportCopy = path.join(output, 'order-summary.json');
+    if (reportCopy !== reportFile) fs.copyFileSync(reportFile, reportCopy);
+    receipt.artifacts.orderReport = reportCopy; receipt.taskId=task.id;
+    receipt.workflow = { expected: actual, owner: peer, status: 'done', proactiveMessageCount: 1, resultRecorded: true, handoffRecorded: true, locksReleased: true, scope: 'isolated representative fixture; not business signoff' };
+    check('real installed worker claims a task, writes correct report, records evidence and handoff, releases lock and completes task');
+  } else receipt.limitations.push('Real model approval and task workflow require --run-live and were not executed.');
+  await hcc(['native','close','--peer',peer]);
+  assert.equal(read(root,'SELECT status FROM peers WHERE id=?',peer)[0].status,'exited');
+  check('installed public close retires only its own native worker');
+  receipt.passed = true;
+} catch (error) { receipt.passed = false; receipt.failure={code:error.code||'ACCEPTANCE_FAILED',message:redactSecrets(error.message),stack:redactSecrets(error.stack)}; process.exitCode=1; }
+finally {
+  try { await rpc?.close(); receipt.cleanup.cordisRuntimeStopped=true; } catch { receipt.cleanup.cordisRuntimeStopped=false; }
+  if (nativeUp) {
+    await hcc(['native','close','--peer',peer]).catch(()=>{});
+    try { await hcc(['native','down']); receipt.cleanup.nativeRuntimeStopped=!fs.existsSync(path.join(root,'.hello-cc/native/runtime.json')); }
+    catch { receipt.cleanup.nativeRuntimeStopped=false; }
+  }
+  fs.rmSync(env.DSH_HOME,{recursive:true,force:true}); receipt.cleanup.privateProviderStateRemoved=true;
+  if (receipt.installedSourceHashes) receipt.currentRuntimeSourcesStillMatch=Object.entries(receipt.installedSourceHashes).every(([file,sha])=>hash(path.join(repo,file))===sha);
+  if (output !== directory) {
+    const evidence = path.join(output, 'evidence', path.basename(directory)); fs.mkdirSync(evidence, { recursive: true });
+    for (const file of fs.readdirSync(directory).filter(file => file.endsWith('.log'))) fs.copyFileSync(path.join(directory, file), path.join(evidence, file));
+    receipt.artifacts.commandLogs = evidence;
+  }
+  receipt.completedAt=new Date().toISOString(); flush();
+  console.log(JSON.stringify({receipt:receiptPath,passed:receipt.passed,checks:receipt.checks.length,cleanup:receipt.cleanup}));
+}