@logicseek/hello-cc 1.0.5 → 1.1.0-rc.3

package/lib/web/ui-terminal-find.mjs

@@ -17,8 +17,10 @@ export function terminalFindHtml() {
   </section>`;
 }
 
-export function terminalFindScript() {
-  return `(() => {
+export function terminalFindScript() { return '(' + installTerminalFind.toString() + ')();'; }
+
+export function installTerminalFind() {
+(() => {
     const host = window.hccTerminalFindHost;
     const bar = document.getElementById('terminalFind');
     const query = document.getElementById('terminalFindQuery');
@@ -94,5 +96,5 @@ export function terminalFindScript() {
     window.addEventListener('hcc:preferences', () => { if (!bar.hidden) { renderResult(); if (query.value) refreshMatches(); } });
     window.hccTerminalFind = {open, close, sync, capturesEscape:event => !bar.hidden && event.key === 'Escape' && (bar.contains(event.target) || host.term.element.contains(event.target))};
     sync();
-  })();`;
+  })();
 }

package/lib/web/ui-workbench.mjs

@@ -29,8 +29,10 @@ export function workbenchControlsHtml() {
 }
 
 // Display state only: the caller owns requests, project scope and retry policy.
-export function workbenchScript() {
-  return `(() => {
+export function workbenchScript() { return '(' + installWorkbench.toString() + ')();'; }
+
+export function installWorkbench() {
+(() => {
     const tabs = document.getElementById('stateTabs');
     const state = document.getElementById('state');
     const notice = document.getElementById('stateFreshness');
@@ -90,5 +92,5 @@ export function workbenchScript() {
     };
     window.addEventListener('hcc:preferences', apply);
     apply();
-  })();`;
+  })();
 }

package/lib/web/ui-workspace.mjs

@@ -133,6 +133,7 @@ function workspaceRuntime(normalize, validMessage) {
     destroy(); mounted = identity; status.hidden = false; status.textContent = tr('workspace.connecting');
     frame = document.createElement('iframe'); frame.id = 'workspaceFrame'; frame.title = tr('workspace.secondary');
     const url = new URL('/pane', location.origin); url.searchParams.set('project',root); url.searchParams.set('session',session.id);
+    if (host.projectIdentity?.()) url.searchParams.set('root_identity', host.projectIdentity());
     frame.src = url.href; secondary.appendChild(frame);
     timer = setTimeout(() => { status.hidden = false; status.textContent = tr('workspace.failed'); byId('workspaceRetry').hidden = false; }, 12000);
   }
@@ -220,3 +221,5 @@ function workspaceRuntime(normalize, validMessage) {
 export function workspaceScript() {
   return '(' + workspaceRuntime.toString() + ')(' + normalizeWorkspaceLayout.toString() + ',' + workspaceMessageValid.toString() + ');';
 }
+
+export function installWorkspace() { workspaceRuntime(normalizeWorkspaceLayout, workspaceMessageValid); }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logicseek/hello-cc",
-  "version": "1.0.5",
+  "version": "1.1.0-rc.3",
   "description": "Local control plane for coordinating Claude Code, Codex, and other coding CLI sessions.",
   "type": "module",
   "bin": {
@@ -32,7 +32,10 @@
     "test": "npm run test:regression",
     "test:audit": "node ./scripts/check-free-identifiers.mjs",
     "test:unit": "node --test test/*.test.mjs",
-    "test:regression": "node ./scripts/regression.mjs"
+    "test:regression": "node ./scripts/regression.mjs",
+    "test:web": "node ./scripts/web-workbench-acceptance.mjs",
+    "test:web:installed": "node ./scripts/web-workbench-installed-acceptance.mjs",
+    "codex:protocol": "node ./scripts/codex-protocol.mjs"
   },
   "repository": {
     "type": "git",
@@ -67,5 +70,8 @@
     "bundle": {
       "patch": "./lib/integrations/dsh.bundle.yml"
     }
+  },
+  "devDependencies": {
+    "playwright": "1.62.1"
   }
 }

package/scripts/benchmark-session-sync.mjs

@@ -0,0 +1,53 @@
+// Fixed-input transport benchmark. No processes, providers, model calls or user sessions.
+import assert from 'node:assert/strict';
+import { performance } from 'node:perf_hooks';
+import { pathToFileURL } from 'node:url';
+import { createSessionStateStream } from '../lib/web/session-state-sync.mjs';
+import { createSessionSync } from '../lib/web/browser/session-sync.mjs';
+
+export function benchmarkSessionSync({ fragments = 1000, batchSize = 5 } = {}) {
+  function fixture() {
+    const turns = Array.from({ length: 9 }, (_, turn) => ({ id: 'history-' + turn, status: 'completed', items:
+      Array.from({ length: 30 }, (_, item) => ({ id: 'item-' + item, type: 'agentMessage', text: 'Fixed retained history '.repeat(48) })) }));
+    turns.push({ id: 'active', status: 'inProgress', items: [{ id: 'message', type: 'agentMessage', text: '' }] });
+    return { executorId: 'benchmark-executor', status: 'ready', threads: [{ id: 'thread', turns }], updateSequence: 0, events: [], truncated: false, pendingApprovals: [] };
+  }
+  function run(incremental) {
+    const state = fixture(), samples = [], cpuStart = process.cpuUsage(), start = performance.now();
+    const stream = incremental ? createSessionStateStream({ root: '/benchmark', sessionId: 'session', channel: 'codex', state, generation: 'benchmark' }) : null;
+    const receiver = createSessionSync({ root: '/benchmark', sessionId: 'session', requestSnapshot() { throw new Error('Unexpected recovery'); } });
+    let bytes = 0, frames = 0, received;
+    function deliver(frame) {
+      const encoded = JSON.stringify(frame); bytes += Buffer.byteLength(encoded); frames++;
+      const decoded = JSON.parse(encoded);
+      if (incremental) { assert.equal(receiver.receive(decoded).accepted, true); received = receiver.state; }
+      else received = decoded.state;
+    }
+    deliver(incremental ? stream.snapshot() : { type: 'codex_state', state: structuredClone(state) });
+    for (let index = 0; index < fragments; index++) {
+      const text = 'token-' + String(index).padStart(4, '0') + '|';
+      state.threads[0].turns[9].items[0].text += text;
+      state.events.push({ method: 'item/agentMessage/delta', params: { threadId: 'thread', turnId: 'active', itemId: 'message', delta: text }, at: index });
+      if (state.events.length > 100) state.events.shift();
+      state.updateSequence++;
+      if ((index + 1) % batchSize === 0 || index === fragments - 1) {
+        const tick = performance.now();
+        deliver(incremental ? stream.update(state, { textOnly: true, textItems: [{ threadId: 'thread', turnId: 'active', itemId: 'message' }] })
+          : { type: 'codex_state', state: structuredClone(state) });
+        samples.push(performance.now() - tick);
+      }
+    }
+    assert.deepEqual(received, state);
+    const cpu = process.cpuUsage(cpuStart), elapsedMs = performance.now() - start;
+    samples.sort((a, b) => a - b);
+    return { frames, bytes, elapsedMs: +elapsedMs.toFixed(3), cpuMs: +((cpu.user + cpu.system) / 1000).toFixed(3),
+      p95DeliveryMs: +samples[Math.floor(samples.length * .95)].toFixed(3), initialStateBytes: Buffer.byteLength(JSON.stringify(fixture())),
+      finalStateBytes: Buffer.byteLength(JSON.stringify(state)), finalOutputCharacters: state.threads[0].turns[9].items[0].text.length };
+  }
+  const legacy = run(false), incremental = run(true);
+  return { workload: { fragments, batchSize, sameInput: true, coldSnapshotIncluded: true, observers: 1 }, legacy, incremental,
+    byteReductionPercent: +((1 - incremental.bytes / legacy.bytes) * 100).toFixed(2),
+    limits: 'Synchronization layer only: server copy/diff/encode plus receiver parse/apply. Excludes provider parsing, SQLite, socket scheduling and browser DOM. Timing is machine-dependent; not production capacity.' };
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) console.log(JSON.stringify(benchmarkSessionSync(), null, 2));

package/scripts/codex-protocol.mjs

@@ -0,0 +1,88 @@
+// Generate the protocol from the selected installed Codex, without starting an
+// App Server, model turn, or login. Existing output directories are never used.
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { CODEX_PROTOCOL_SCHEMA_FILES, CODEX_PROTOCOL_SCHEMA_PATHS, inspectCodexProtocol } from '../lib/diagnostics/codex-protocol.mjs';
+
+function argumentsFor(argv) {
+  const options = { binary: 'codex', out: null };
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === '--help' || argv[i] === '-h') return { help: true };
+    if (!['--codex-bin', '--out'].includes(argv[i]) || !argv[i + 1] || argv[i + 1].startsWith('--')) throw new Error('Use --codex-bin PATH and/or --out NEW_DIRECTORY');
+    const key = argv[i] === '--codex-bin' ? 'binary' : 'out';
+    options[key] = argv[++i];
+  }
+  if (options.binary.includes(path.sep) || options.binary.includes('/')) options.binary = path.resolve(options.binary);
+  if (options.out) options.out = path.resolve(options.out);
+  return options;
+}
+function inventory(directory, parent = directory) {
+  return fs.readdirSync(parent, { withFileTypes: true }).flatMap(entry => {
+    const file = path.join(parent, entry.name);
+    if (entry.isDirectory()) return inventory(directory, file);
+    if (!entry.isFile()) throw new Error('Generated protocol contains a non-regular file');
+    return [{ path: path.relative(directory, file).split(path.sep).join('/'),
+      sha256: createHash('sha256').update(fs.readFileSync(file)).digest('hex') }];
+  }).sort((a, b) => a.path.localeCompare(b.path, 'en'));
+}
+
+let workspace;
+try {
+  const options = argumentsFor(process.argv.slice(2));
+  if (options.help) {
+    console.log('node scripts/codex-protocol.mjs [--codex-bin PATH] [--out NEW_DIRECTORY]\nGenerates official TypeScript and JSON Schema with --experimental, checks the HCC subset, and records version and file hashes. No model or account access. Output must not already exist.');
+  } else {
+    workspace = fs.mkdtempSync(path.join(os.tmpdir(), 'hcc-codex-protocol-'));
+    fs.chmodSync(workspace, 0o700);
+    const home = path.join(workspace, 'home'), codexHome = path.join(workspace, 'codex-home');
+    fs.mkdirSync(home, { mode: 0o700 }); fs.mkdirSync(codexHome, { mode: 0o700 });
+    const output = options.out || path.join(workspace, 'protocol');
+    fs.mkdirSync(output, { mode: 0o700 });
+    const env = { PATH: process.env.PATH, HOME: home, USERPROFILE: home, CODEX_HOME: codexHome,
+      APPDATA: home, LOCALAPPDATA: home, TMPDIR: workspace, TEMP: workspace, TMP: workspace,
+      HCC_SHIM_NO_ATTACH: '1', HCC_SHIM_ENSURED: '1', NO_COLOR: '1' };
+    const run = args => {
+      const result = spawnSync(options.binary, args, { cwd: workspace, env, encoding: 'utf8',
+        timeout: 30000, maxBuffer: 256 * 1024, stdio: ['ignore', 'pipe', 'pipe'] });
+      // Arbitrary executable output must not appear in a failure receipt.
+      if (result.error || result.status !== 0) throw new Error(`Codex protocol command failed: ${args.slice(0, 2).join(' ')}`);
+      return result.stdout.trim();
+    };
+    const versionOutput = run(['--version']);
+    const version = /^codex-cli (\d+\.\d+\.\d+(?:[-+][A-Za-z0-9.-]+)?)$/.exec(versionOutput)?.[1];
+    if (!version) throw new Error('Codex returned an unrecognized version');
+    const commands = [['app-server', 'generate-json-schema', '--experimental', '--out', path.join(output, 'json-schema')],
+      ['app-server', 'generate-ts', '--experimental', '--out', path.join(output, 'typescript')]];
+    for (const command of commands) run(command);
+    if (run(['--version']) !== versionOutput) throw new Error('Codex version changed during generation');
+    let schemas;
+    try {
+      schemas = Object.fromEntries(CODEX_PROTOCOL_SCHEMA_FILES.map(name => [name,
+        JSON.parse(fs.readFileSync(path.join(output, 'json-schema', CODEX_PROTOCOL_SCHEMA_PATHS[name]), 'utf8'))]));
+    } catch { throw new Error('Official JSON Schema output is missing or invalid'); }
+    const contract = inspectCodexProtocol(schemas);
+    const files = inventory(output);
+    if (!files.some(file => file.path === 'typescript/ClientRequest.ts') || !files.some(file => file.path === 'typescript/ServerRequest.ts')) throw new Error('Official TypeScript output is incomplete');
+    const manifest = { schemaVersion: 1, codexVersion: version, experimental: true,
+      commands: commands.map(command => [...command.slice(0, -1), path.relative(output, command.at(-1))]),
+      contract, files, bundleSha256: createHash('sha256').update(JSON.stringify(files)).digest('hex') };
+    fs.writeFileSync(path.join(output, 'manifest.json'), JSON.stringify(manifest, null, 2) + '\n', { mode: 0o600 });
+    if (!options.out) workspace = null; // Retain generated output; remove only disposable homes.
+    fs.rmSync(home, { recursive: true, force: true }); fs.rmSync(codexHome, { recursive: true, force: true });
+    console.log(JSON.stringify({ outputDirectory: output, codexVersion: version, status: contract.status,
+      checks: contract.checks.length, failedChecks: contract.checks.filter(check => check.status === 'fail'),
+      unsupportedServerRequests: contract.unsupportedServerRequests, fileCount: files.length,
+      bundleSha256: manifest.bundleSha256, inferenceCalled: false, accountAccessed: false }));
+    if (contract.status !== 'compatible') process.exitCode = 1;
+  }
+} catch (error) {
+  console.error(JSON.stringify({ ok: false, code: 'CODEX_PROTOCOL_GENERATION_FAILED',
+    message: error.code === 'EEXIST' ? 'Output directory already exists; choose a new directory' :
+      error.code === 'ENOENT' ? 'Codex executable or generated protocol file is missing' : error.message }));
+  process.exitCode = 1;
+} finally {
+  if (workspace) fs.rmSync(workspace, { recursive: true, force: true });
+}

package/scripts/dsh-approval-layers-acceptance.mjs

@@ -0,0 +1,172 @@
+// Deterministic local Messages responses drive the real official Harness and
+// the production ACP adapter. No real model, credential or global profile.
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import http from 'node:http';
+import { createHash, randomUUID } from 'node:crypto';
+import { spawnSync } from 'node:child_process';
+import { setTimeout as delay } from 'node:timers/promises';
+import { fileURLToPath } from 'node:url';
+import { createDshAcpAdapter } from '../lib/integrations/native/dsh-acp.mjs';
+import { createDshEnvironment, resolveDshBinary } from '../lib/integrations/dsh.mjs';
+import { isKnownDshEscalationApproval } from './web-native-interaction-diagnostics.mjs';
+
+const args = process.argv.slice(2);
+if (args.includes('--help')) {
+  console.log('Usage: node scripts/dsh-approval-layers-acceptance.mjs [--dsh-bin PATH] [--output FILE]');
+  process.exit(0);
+}
+const option = (name, fallback) => args.includes(name) ? args[args.indexOf(name) + 1] : fallback;
+const requestedBinary = option('--dsh-bin');
+let binary;
+if (requestedBinary && /\.(?:mjs|cjs|js)$/.test(requestedBinary)) {
+  binary = fs.realpathSync(path.resolve(requestedBinary));
+  assert.ok(fs.statSync(binary).isFile(), 'Explicit JavaScript launcher must be a regular file');
+  fs.accessSync(binary, fs.constants.R_OK);
+} else binary = resolveDshBinary({ dshBin: requestedBinary });
+assert.ok(binary, 'An existing official DSH launcher is required');
+const sandbox = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'hcc-dsh-approval-layers-')));
+fs.chmodSync(sandbox, 0o700);
+// npm's bin.js may be a non-executable source file. Use this run's Node 24
+// explicitly without changing installed file modes or the product transport.
+const quote = value => "'" + value.replaceAll("'", "'\\''") + "'";
+let launcher = binary;
+if (/\.(?:mjs|cjs|js)$/.test(binary)) {
+  launcher = path.join(sandbox, 'official-dsh');
+  fs.writeFileSync(launcher, '#!/bin/sh\nexec ' + quote(process.execPath) + ' ' + quote(binary) + ' "$@"\n', { mode: 0o700 });
+}
+const output = path.resolve(option('--output', path.join(sandbox, 'evidence.json')));
+const repo = fileURLToPath(new URL('..', import.meta.url));
+const hash = file => createHash('sha256').update(fs.readFileSync(file)).digest('hex');
+const sourceFiles = Object.fromEntries(['scripts/dsh-approval-layers-acceptance.mjs', 'lib/integrations/native/dsh-acp.mjs',
+  'lib/integrations/native/jsonrpc.mjs', 'lib/integrations/native/interactions.mjs',
+  'scripts/web-native-interaction-diagnostics.mjs'].map(name => [name, hash(path.join(repo, name))]));
+const receipt = { schemaVersion: 1, startedAt: new Date().toISOString(), sourceFiles,
+  mode: 'Deterministic local Messages server; actual official Harness and production ACP adapter',
+  realModelCalls: false, scenarios: [], completed: false, cleanup: false };
+const scenarios = [
+  { name: 'policy-only-allow', forcedAsk: true, escalation: false, decisions: ['accept'], written: true },
+  { name: 'policy-and-escalation-allow', forcedAsk: true, escalation: true, decisions: ['accept', 'accept'], written: true },
+  { name: 'policy-allow-escalation-decline', forcedAsk: true, escalation: true, decisions: ['accept', 'decline'], written: false },
+  { name: 'policy-decline', forcedAsk: true, escalation: true, decisions: ['decline'], written: false },
+  { name: 'escalation-only-allow', forcedAsk: false, escalation: true, decisions: ['accept'], written: true },
+];
+
+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-fixture', 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 {
+  for (const scenario of scenarios) {
+    const directory = path.join(sandbox, scenario.name), root = path.join(directory, 'project'), home = path.join(directory, 'home');
+    const target = path.join(directory, 'target.txt'), marker = 'DETERMINISTIC_APPROVAL_OK', callId = 'call-' + scenario.name;
+    for (const folder of [directory, root, home]) fs.mkdirSync(folder, { mode: 0o700 });
+    let requests = 0, completed, adapter, server;
+    const observed = { name: scenario.name, requests: [], modelRequests: 0, realModelCalls: false, completed: false };
+    receipt.scenarios.push(observed);
+    try {
+      server = http.createServer(async (request, response) => {
+        try {
+          assert.equal(request.method, 'POST');
+          const chunks = []; let length = 0;
+          for await (const chunk of request) { length += chunk.length; assert.ok(length < 2 * 1024 * 1024); chunks.push(chunk); }
+          const body = JSON.parse(Buffer.concat(chunks).toString());
+          requests++;
+          assert.ok(requests <= 2, 'The fixture never emits another tool call or retries');
+          if (requests === 1) {
+            assert.ok(body.tools.some(tool => tool.name === 'write'));
+            stream(response, body.model, { type: 'tool_use', id: callId, name: 'write', input: {
+              file_path: target, content: marker,
+              ...(scenario.escalation ? { sandbox_permissions: 'danger-full-access', justification: 'Only this temporary acceptance target.' } : {}),
+            } });
+          } else {
+            observed.toolResultReceived = body.messages.some(message => Array.isArray(message.content) &&
+              message.content.some(block => block.type === 'tool_result' && block.tool_use_id === callId));
+            stream(response, body.model, { type: 'text', text: 'DETERMINISTIC_DONE' });
+          }
+        } catch (error) { response.writeHead(500); response.end(JSON.stringify({ error: { type: 'api_error', message: error.message } })); }
+      });
+      await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
+      const env = createDshEnvironment({ PATH: process.env.PATH, LANG: 'C.UTF-8', SHELL: '/bin/sh' });
+      Object.assign(env, { HOME: home, DSH_HOME: path.join(home, 'dsh'), TMPDIR: directory, DSH_TELEMETRY_DISABLED: '1',
+        DEEPSEEK_API_KEY: 'isolated-local-no-credential', DEEPSEEK_BASE_URL: `http://127.0.0.1:${server.address().port}` });
+      const initialized = spawnSync(launcher, ['--profile', 'acp', '--dump-config'], { cwd: root, env, encoding: 'utf8', timeout: 30000 });
+      assert.equal(initialized.status, 0, 'Isolated profile initialization failed (config omitted)');
+      if (scenario.forcedAsk) {
+        const policy = path.join(directory, 'policy.mjs');
+        fs.writeFileSync(policy, `export const inject=['tools'];export function apply(ctx){ctx.on('tools/pre-execute',async(exec,next)=>exec.name==='write'&&exec.arguments.file_path===${JSON.stringify(target)}?{kind:'ask',reason:'exact test-owned write'}:next());}\n`, { mode: 0o600 });
+        fs.writeFileSync(path.join(env.DSH_HOME, 'profiles/acp/cordis.patch.yml'), '- insert:\n    - id: deterministic-approval-policy\n      name: ' + JSON.stringify(policy) + '\n', { mode: 0o600 });
+      }
+      adapter = createDshAcpAdapter({ binary: launcher, cwd: root, env, interactive: true, executorId: randomUUID(),
+        onEvent(event) { if (event.type === 'completed') completed = { status: event.status, stopReason: event.stopReason }; } });
+      const opened = await adapter.open();
+      const sent = await adapter.send({ text: 'Execute the one fixture tool, then finish.', submissionId: randomUUID() });
+      const seen = new Set(), deadline = Date.now() + 30000;
+      let firstRequest;
+      while (!completed && Date.now() < deadline) {
+        const snapshot = adapter.snapshot();
+        assert.ok(!snapshot.error, 'Unexpected ACP runtime error');
+        for (const pending of snapshot.pendingApprovals) {
+          assert.ok(!seen.has(pending.requestId), 'Answered request must leave pending state');
+          assert.equal(pending.method, 'session/request_permission');
+          assert.equal(pending.sessionId, opened.sessionId); assert.equal(pending.turnId, sent.turnId);
+          assert.equal(pending.params.toolCall.toolCallId, callId); assert.equal(pending.params.toolCall.title, 'write');
+          assert.equal(pending.params.toolCall.rawInput.file_path, target); assert.equal(pending.params.toolCall.rawInput.content, marker);
+          const decision = scenario.decisions[observed.requests.length];
+          assert.ok(decision, 'Unexpected additional approval is never answered');
+          if (firstRequest) {
+            assert.equal(isKnownDshEscalationApproval(firstRequest, pending, {
+              target, content: marker, priorDecision: scenario.decisions[0], additionalAnswers: observed.requests.length - 1,
+            }), true, 'The actual official second layer must satisfy the fixture operation guard');
+          } else firstRequest = structuredClone(pending);
+          observed.requests.push({ requestId: pending.requestId, method: pending.method, toolName: 'write',
+            toolCallId: callId, sameOriginalSession: true, sameOriginalTurn: true, targetExactOwned: true,
+            targetExistsBeforeAnswer: fs.existsSync(target), decision });
+          seen.add(pending.requestId);
+          adapter.respond({ executorId: pending.executorId, requestId: pending.requestId, sessionId: pending.sessionId, turnId: pending.turnId, decision });
+        }
+        await delay(20);
+      }
+      assert.equal(completed?.status, 'completed'); assert.equal(completed?.stopReason, 'end_turn');
+      assert.equal(observed.requests.length, scenario.decisions.length);
+      assert.equal(fs.existsSync(target), scenario.written);
+      if (scenario.written) assert.equal(fs.readFileSync(target, 'utf8'), marker);
+      assert.equal(requests, 2); assert.equal(observed.toolResultReceived, true);
+      observed.targetExistsAfterCompletion = fs.existsSync(target);
+      observed.targetSha256 = fs.existsSync(target) ? hash(target) : null;
+      observed.oneModelToolCall = true; observed.modelRequests = requests; observed.completed = true;
+      console.log(JSON.stringify({ scenario: scenario.name, permissionRequests: observed.requests.length, written: scenario.written, passed: true }));
+    } finally {
+      await adapter?.close();
+      if (server) { server.closeAllConnections(); await new Promise(resolve => server.close(resolve)); }
+      fs.rmSync(directory, { recursive: true, force: true });
+    }
+  }
+  receipt.completed = true;
+} catch (error) {
+  receipt.error = { name: error.name, message: error.message }; process.exitCode = 1;
+} finally {
+  receipt.cleanup = scenarios.every(scenario => !fs.existsSync(path.join(sandbox, scenario.name)));
+  if (launcher !== binary) {
+    try { fs.rmSync(launcher); } catch { receipt.cleanup = false; }
+  }
+  receipt.finishedAt = new Date().toISOString();
+  receipt.sourceChanges = Object.entries(sourceFiles).filter(([name, before]) => hash(path.join(repo, name)) !== before).map(([name]) => name);
+  if (!receipt.cleanup || receipt.sourceChanges.length) {
+    receipt.completed = false; process.exitCode = 1;
+    receipt.error ||= { name: 'AcceptanceIntegrityError', message: 'Owned cleanup failed or source changed during acceptance' };
+  }
+  fs.mkdirSync(path.dirname(output), { recursive: true });
+  fs.writeFileSync(output, JSON.stringify(receipt, null, 2) + '\n', { mode: 0o600 });
+  console.log(JSON.stringify({ output, completed: receipt.completed, cleanup: receipt.cleanup, error: receipt.error }));
+}

package/scripts/dsh-package-provenance.mjs

@@ -0,0 +1,118 @@
+// Freeze a checkout candidate or verify an immutable release without installing
+// Harness, calling a model, changing an archive, or publishing a package.
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { createHash } from 'node:crypto';
+import { execFileSync } from 'node:child_process';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const ARCHIVED_BASELINE = 'docs/verification/dsh-1.0.3-package.json';
+const hash = file => createHash('sha256').update(fs.readFileSync(file)).digest('hex');
+
+export function resolveAcceptanceMode({ eventName, ref, dispatchMode } = {}) {
+  if (ref?.startsWith('refs/tags/v')) return 'release';
+  if (eventName !== 'workflow_dispatch') return 'candidate';
+  const mode = dispatchMode || 'release';
+  assert.ok(['candidate', 'release'].includes(mode), 'Acceptance mode must be candidate or release');
+  return mode;
+}
+
+export function selectAcceptancePackage({ repo, metadata, candidateTarball, packageDir, mode,
+  archivedManifest = ARCHIVED_BASELINE }) {
+  assert.ok(['candidate', 'release'].includes(mode), 'Acceptance mode must be candidate or release');
+  // A development version need not have a release manifest yet. Its archived
+  // integrity baseline is explicit and independent of its package version.
+  const manifestPath = mode === 'release'
+    ? `docs/verification/dsh-${metadata.version}-package.json` : archivedManifest;
+  const frozen = JSON.parse(fs.readFileSync(path.resolve(repo, manifestPath), 'utf8'));
+  assert.equal(path.basename(frozen.filename), frozen.filename, 'Archive filename must be a basename');
+  const frozenArtifact = path.join(repo, 'docs', 'verification', frozen.filename);
+  assert.equal(hash(frozenArtifact), frozen.sha256, 'Stored release artifact must match its frozen digest');
+  let frozenContentMatch = null;
+  if (mode === 'release') {
+    assert.equal(metadata.version, frozen.version, 'Frozen manifest version must match');
+    assert.deepEqual(metadata.files.map(file => file.path).sort(), Object.keys(frozen.files).sort(),
+      'The package file set must match the frozen release artifact');
+    for (const file of metadata.files) {
+      assert.equal(hash(path.join(packageDir, file.path)), frozen.files[file.path], `Frozen release file differs: ${file.path}`);
+      assert.equal(file.mode, frozen.fileModes[file.path], `Package mode differs: ${file.path}`);
+    }
+    frozenContentMatch = true;
+  }
+  return {
+    mode, acceptanceTarget: mode === 'release' ? 'immutable-release' : 'checkout-candidate',
+    tarball: mode === 'release' ? frozenArtifact : candidateTarball,
+    frozenContentMatch,
+    archiveIntegrity: { manifest: manifestPath, version: frozen.version,
+      filename: frozen.filename, sha256: frozen.sha256, verified: true }
+  };
+}
+
+export function freezeAcceptancePackage({ root, repo = fileURLToPath(new URL('..', import.meta.url)),
+  mode, env = process.env }) {
+  assert.ok(root, 'HCC_DSH_ACCEPTANCE_ROOT or --output-dir is required');
+  assert.ok(['candidate', 'release'].includes(mode), 'Acceptance mode must be candidate or release');
+  root = path.resolve(root);
+  fs.mkdirSync(root, { recursive: true, mode: 0o700 });
+  // Require fresh output directories so an earlier extraction cannot supply
+  // stale files to this run's source comparison or acceptance script.
+  for (const name of ['home', 'official', 'candidate', 'candidate-unpacked', 'unpacked', 'evidence']) {
+    fs.mkdirSync(path.join(root, name), { mode: 0o700 });
+  }
+  const childEnv = { ...env, HOME: path.join(root, 'home'), DSH_HOME: path.join(root, 'home', 'dsh'),
+    NPM_CONFIG_CACHE: path.join(root, 'npm-cache'), NPM_CONFIG_USERCONFIG: path.join(root, 'home', '.npmrc') };
+  for (const key of ['DEEPSEEK_API_KEY', 'OPENAI_API_KEY', 'ANTHROPIC_API_KEY']) delete childEnv[key];
+  const run = (command, args) => execFileSync(command, args, { cwd: repo, env: childEnv, encoding: 'utf8', maxBuffer: 8 * 1024 * 1024 });
+  const npm = args => env.npm_execpath
+    ? run(process.execPath, [env.npm_execpath, ...args]) : run('npm', args);
+  const metadata = JSON.parse(npm(['pack', '--ignore-scripts', '--json', '--pack-destination', path.join(root, 'candidate')]))[0];
+  if (env.GITHUB_REF?.startsWith('refs/tags/v')) {
+    assert.equal(mode, 'release', 'Version tags require immutable release acceptance');
+    assert.equal(env.GITHUB_REF.slice('refs/tags/v'.length), metadata.version, 'Version tag must match the package version');
+  }
+  const candidateTarball = path.join(root, 'candidate', metadata.filename);
+  run('tar', ['-xzf', candidateTarball, '-C', path.join(root, 'candidate-unpacked')]);
+  const selected = selectAcceptancePackage({ repo, metadata, candidateTarball, mode,
+    packageDir: path.join(root, 'candidate-unpacked', 'package') });
+  // The script and the installed archive must come from the same selected
+  // package. Release mode must not run a candidate script against the archive.
+  run('tar', ['-xzf', selected.tarball, '-C', path.join(root, 'unpacked')]);
+  const receipt = {
+    schemaVersion: 2, createdAt: new Date().toISOString(),
+    revision: run('git', ['rev-parse', 'HEAD']).trim(),
+    platform: { os: process.platform, architecture: process.arch, node: process.version },
+    harness: '0.2.0-rc.2', pnpm: '12.8.1', npm: npm(['--version']).trim(),
+    mode, acceptanceTarget: selected.acceptanceTarget,
+    archiveIntegrity: selected.archiveIntegrity, frozenContentMatch: selected.frozenContentMatch,
+    repackedSha256: hash(candidateTarball),
+    package: { name: metadata.name, version: metadata.version, filename: path.basename(selected.tarball),
+      fileCount: metadata.files.length, sha256: hash(selected.tarball) },
+    registryReadbackPerformed: false, npmPublicationRequested: false,
+    validation: mode === 'candidate'
+      ? 'Checkout candidate installation on a CI runner; not a published-package, device or business acceptance'
+      : 'Immutable archived release installation on a CI runner; no registry readback, device or business acceptance'
+  };
+  fs.writeFileSync(path.join(root, 'evidence', 'package-provenance.json'), JSON.stringify(receipt, null, 2) + '\n');
+  fs.writeFileSync(path.join(root, 'candidate.json'), JSON.stringify({ tarball: selected.tarball, mode, acceptanceTarget: selected.acceptanceTarget }));
+  fs.writeFileSync(path.join(root, 'official', 'package.json'), JSON.stringify({ name: 'hcc-isolated-dsh-acceptance', private: true, version: '0.0.0' }));
+  if (env.GITHUB_OUTPUT) fs.appendFileSync(env.GITHUB_OUTPUT, `mode=${mode}\nacceptanceTarget=${selected.acceptanceTarget}\n`);
+  return receipt;
+}
+
+if (process.argv[1] && pathToFileURL(path.resolve(process.argv[1])).href === import.meta.url) {
+  try {
+    const options = new Map();
+    for (let index = 2; index < process.argv.length; index += 2) {
+      const key = process.argv[index], value = process.argv[index + 1];
+      assert.ok(['--mode', '--output-dir'].includes(key) && value && !value.startsWith('--'), `Invalid option: ${key}`);
+      options.set(key, value);
+    }
+    const mode = options.get('--mode') || resolveAcceptanceMode({ eventName: process.env.GITHUB_EVENT_NAME,
+      ref: process.env.GITHUB_REF, dispatchMode: process.env.HCC_DSH_DISPATCH_MODE });
+    console.log(JSON.stringify(freezeAcceptancePackage({ root: options.get('--output-dir') || process.env.HCC_DSH_ACCEPTANCE_ROOT, mode }), null, 2));
+  } catch (error) {
+    const details = String(error.stack || error.message || error).replaceAll('%', '%25').replaceAll('\r', '%0D').replaceAll('\n', '%0A');
+    console.error(`::error::${details}`); process.exitCode = 1;
+  }
+}

package/scripts/mcp-form-live-fixture.mjs

@@ -0,0 +1,81 @@
+// Disposable stdio MCP server for installed-model form acceptance.
+// Only synthetic inputs from this harness are recorded; no provider credentials.
+import fs from 'node:fs';
+import readline from 'node:readline';
+import { randomUUID } from 'node:crypto';
+
+const args = process.argv.slice(2);
+if (!args.includes('--stdio')) {
+  console.log('Acceptance fixture only: node scripts/mcp-form-live-fixture.mjs --stdio --log FILE');
+  process.exit(0);
+}
+const logIndex = args.indexOf('--log');
+if (logIndex < 0 || !args[logIndex + 1]) throw new Error('--log FILE is required');
+const logPath = args[logIndex + 1];
+const pending = new Map();
+const write = value => process.stdout.write(JSON.stringify({ jsonrpc: '2.0', ...value }) + '\n');
+const record = value => fs.appendFileSync(logPath, JSON.stringify({ at: new Date().toISOString(), pid: process.pid, ...value }) + '\n', { mode: 0o600 });
+const reply = (id, result) => write({ id, result });
+const schema = {
+  type: 'object',
+  properties: {
+    project: { type: 'string', title: 'Project name / 项目名', minLength: 3, maxLength: 64 },
+    count: { type: 'integer', title: 'Run count / 次数', minimum: 1, maximum: 4 },
+    enabled: { type: 'boolean', title: 'Enable extra operation / 开启额外操作' },
+    region: { type: 'string', title: 'Region / 地区', enum: ['eu', 'us'], enumNames: ['Europe', 'USA'] },
+    features: { type: 'array', title: 'Features / 功能', minItems: 1, maxItems: 2,
+      items: { type: 'string', enum: ['logs', 'tests'] } },
+    note: { type: 'string', title: 'Optional note / 可选备注', default: 'suggested-but-not-automatically-submitted' }
+  },
+  required: ['project', 'count', 'enabled', 'region', 'features']
+};
+const lines = readline.createInterface({ input: process.stdin });
+lines.on('line', line => {
+  let message;
+  try { message = JSON.parse(line); } catch { write({ id: null, error: { code: -32700, message: 'Invalid JSON' } }); return; }
+  const { id, method, params = {} } = message;
+  if (!method) {
+    const entry = pending.get(id);
+    if (!entry) return;
+    pending.delete(id); clearTimeout(entry.timer);
+    record({ event: 'form-response', phase: entry.phase, elicitationId: id, response: message.result ?? null,
+      ...(message.error ? { error: { code: message.error.code } } : {}) });
+    if (message.error) { reply(entry.callId, { content: [{ type: 'text', text: 'Form failed' }], isError: true }); return; }
+    reply(entry.callId, { content: [{ type: 'text', text: JSON.stringify({ phase: entry.phase, ...message.result }) }] });
+    return;
+  }
+  if (method === 'initialize') {
+    record({ event: 'initialize', protocolVersion: params.protocolVersion, clientName: params.clientInfo?.name,
+      elicitationCapabilities: params.capabilities?.elicitation ?? null });
+    reply(id, { protocolVersion: params.protocolVersion, capabilities: { tools: {} },
+      serverInfo: { name: 'hcc-form-live-acceptance', version: '1.0.0' } });
+  } else if (method === 'notifications/initialized') {
+    record({ event: 'ready' });
+  } else if (method === 'ping') {
+    reply(id, {});
+  } else if (method === 'tools/list') {
+    reply(id, { tools: [{ name: 'collect_project_settings',
+      description: 'Ask the human for project settings in a typed MCP form. Wait for their response and return the selected values.',
+      inputSchema: { type: 'object', properties: { phase: { type: 'string', enum: ['native', 'web-owned'] } },
+        required: ['phase'], additionalProperties: false } }] });
+  } else if (method === 'tools/call') {
+    const phase = params.arguments?.phase;
+    if (params.name !== 'collect_project_settings' || !['native', 'web-owned'].includes(phase)) {
+      write({ id, error: { code: -32602, message: 'Unknown acceptance tool or phase' } }); return;
+    }
+    const elicitationId = 'acceptance-form-' + randomUUID();
+    const timer = setTimeout(() => {
+      if (!pending.delete(elicitationId)) return;
+      record({ event: 'form-timeout', phase, elicitationId });
+      reply(id, { content: [{ type: 'text', text: 'Acceptance form timed out' }], isError: true });
+    }, 240000);
+    pending.set(elicitationId, { callId: id, phase, timer });
+    record({ event: 'tool-called', phase, elicitationId });
+    write({ id: elicitationId, method: 'elicitation/create', params: { mode: 'form',
+      message: 'Acceptance only: provide synthetic project settings / 验收表单：填写合成项目参数', requestedSchema: schema } });
+    record({ event: 'form-requested', phase, elicitationId });
+  } else if (id !== undefined) {
+    write({ id, error: { code: -32601, message: 'Method not found' } });
+  }
+});
+lines.on('close', () => { for (const entry of pending.values()) clearTimeout(entry.timer); pending.clear(); });