@logicseek/hello-cc 1.1.0 → 1.1.1

package/lib/runtime/native/cli-submissions.mjs

@@ -124,6 +124,9 @@ function optionalRecord(directory, name) {
 function validatePrepared(record, id, root, meshDbRelative) {
   if (record?.version !== 1 || record.submission_id !== id ||
       record.root !== root || record.mesh_db_relative !== meshDbRelative ||
+      typeof record.mesh_db_relative !== 'string' || !record.mesh_db_relative ||
+      path.isAbsolute(record.mesh_db_relative) || path.win32.isAbsolute(record.mesh_db_relative) ||
+      record.mesh_db_relative.split(/[\\/]/).includes('..') ||
       typeof record.peer !== 'string' || !record.peer || typeof record.from !== 'string' || !record.from ||
       !(record.task_id === null || (Number.isSafeInteger(record.task_id) && record.task_id > 0)) ||
       !/^[a-f0-9]{64}$/.test(record.body_sha256) ||
@@ -200,7 +203,12 @@ export function listCliSubmissions(ctx, { peer = null } = {}) {
   for (const name of fs.readdirSync(directory)) {
     const match = name.match(PREPARED);
     if (!match) continue;
-    const record = validatePrepared(readRecord(directory, name), match[1], root, meshDbRelative);
+    // Journals are shared by all coordination databases in this project. Check
+    // the saved binding before filtering; retry lookup still requires the
+    // currently selected database so an ID cannot be replayed across them.
+    const saved = readRecord(directory, name);
+    const record = validatePrepared(saved, match[1], root, saved?.mesh_db_relative);
+    if (record.mesh_db_relative !== meshDbRelative) continue;
     if (peer && record.peer !== peer) continue;
     const receiptName = `receipt-${record.submission_id}.json`;
     let receipt = optionalRecord(directory, receiptName);

package/lib/runtime/native/service.mjs

@@ -90,6 +90,9 @@ export async function startNativeService(ctx, deps, options = {}) {
         ? 'An ownership listener has no identity handshake and may belong to an older native runtime. Stop that runtime before retrying.'
         : 'A native runtime already owns this project, or all ownership ports are unavailable.');
     }
+    if (error?.code === 'ERR_FILE_LOCK_WORKER_START_FAILED' && error.listener) {
+      throw new CliError('NATIVE_OWNERSHIP_UNAVAILABLE', 'Cannot start the native runtime ownership listener', error.listener);
+    }
     throw error;
   }
   let store;

package/lib/shared/file-lock.mjs

@@ -3,6 +3,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { Worker } from 'node:worker_threads';
 import { aggregateCleanupFailure } from './cleanup-error.mjs';
+import { readSocketLockFailure, SOCKET_LOCK_STATE_LENGTH } from './socket-lock-diagnostics.mjs';
 
 const NO_ERROR = Symbol('no-file-lock-error');
 const STATE_INDEX = 0;
@@ -193,7 +194,10 @@ function injectedFailure(worker, state, phase, key) {
   } catch (error) {
     return workerError(key, phase, error);
   }
-  return workerError(key, phase);
+  const error = workerError(key, phase);
+  const listener = readSocketLockFailure(state);
+  if (listener) error.listener = listener;
+  return error;
 }
 
 function terminateWorker(worker, primary, key) {
@@ -241,7 +245,7 @@ function acquisitionError(status, resources) {
 }
 
 function acquireWorker(location, options, workerFactory) {
-  const buffer = new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT * 2);
+  const buffer = new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT * SOCKET_LOCK_STATE_LENGTH);
   const state = new Int32Array(buffer);
   const endpoints = endpointsForLocation(location);
   const targets = lockTargetsForLocation(location);

package/lib/shared/socket-lock-diagnostics.mjs

@@ -0,0 +1,31 @@
+// Only bounded numeric fields cross the synchronous worker boundary. Never
+// copy a listener error's message, path, address, or arbitrary properties.
+export const SOCKET_LOCK_STATE_LENGTH = 6;
+const CODE_INDEX = 2;
+const ERRNO_INDEX = 3;
+const SYSCALL_INDEX = 4;
+const PORT_INDEX = 5;
+const CODES = Object.freeze([null, 'EACCES', 'EPERM', 'EMFILE', 'ENFILE', 'ENOBUFS',
+  'ENOMEM', 'EADDRNOTAVAIL', 'EAFNOSUPPORT', 'EINVAL', 'ENOTSOCK', 'EBADF', 'EADDRINUSE']);
+const SYSCALLS = Object.freeze([null, 'listen', 'bind', 'accept', 'close']);
+
+export function writeSocketLockFailure(state, error, port) {
+  if (state.length < SOCKET_LOCK_STATE_LENGTH) return;
+  Atomics.store(state, CODE_INDEX, Math.max(0, CODES.indexOf(error?.code)));
+  const errno = error?.errno;
+  Atomics.store(state, ERRNO_INDEX, Number.isInteger(errno) && Math.abs(errno) <= 65535 ? errno : 0);
+  Atomics.store(state, SYSCALL_INDEX, Math.max(0, SYSCALLS.indexOf(error?.syscall)));
+  Atomics.store(state, PORT_INDEX, Number.isInteger(port) && port > 0 && port <= 65535 ? port : 0);
+}
+
+export function readSocketLockFailure(state) {
+  if (state.length < SOCKET_LOCK_STATE_LENGTH) return null;
+  const port = Atomics.load(state, PORT_INDEX);
+  if (port < 1 || port > 65535) return null;
+  return {
+    cause: { code: CODES[Atomics.load(state, CODE_INDEX)] ?? null,
+      errno: Atomics.load(state, ERRNO_INDEX) || null,
+      syscall: SYSCALLS[Atomics.load(state, SYSCALL_INDEX)] ?? null },
+    endpoint: { host: '127.0.0.1', port }
+  };
+}

package/lib/shared/socket-lock-worker.mjs

@@ -1,5 +1,6 @@
 import net from 'node:net';
 import { parentPort } from 'node:worker_threads';
+import { writeSocketLockFailure } from './socket-lock-diagnostics.mjs';
 
 const STATE_INDEX = 0;
 const DETAIL_INDEX = 1;
@@ -85,8 +86,9 @@ export function runSocketLockWorker(workerData) {
     complete();
   }
 
-  function requestTerminalFailure() {
+  function requestTerminalFailure(error = null, port = 0) {
     if (finished) return;
+    if (!terminalFailureRequested) writeSocketLockFailure(state, error, port);
     terminalFailureRequested = true;
     generation += 1;
     closeServers(() => finish(states.FAILED, 1));
@@ -184,7 +186,7 @@ export function runSocketLockWorker(workerData) {
       const bindError = (error) => {
         if (finished || attemptGeneration !== generation) return;
         if (error?.code !== 'EADDRINUSE') {
-          requestTerminalFailure();
+          requestTerminalFailure(error, port);
           return;
         }
         probeOccupant(port, target.identity, (matching, legacy) => {
@@ -206,12 +208,12 @@ export function runSocketLockWorker(workerData) {
           return;
         }
         candidate.off('error', bindError);
-        candidate.on('error', requestTerminalFailure);
+        candidate.on('error', error => requestTerminalFailure(error, port));
         servers.push(candidate);
         bindCandidate(targetIndex, candidateIndex + 1, boundForTarget + 1, attemptGeneration);
       });
-    } catch {
-      requestTerminalFailure();
+    } catch (error) {
+      requestTerminalFailure(error, port);
     }
   }
 

package/lib/web/context-files.mjs

@@ -1,10 +1,8 @@
-import fs from 'node:fs/promises';
 import path from 'node:path';
-import process from 'node:process';
 import { CliError } from '../shared/errors.mjs';
 import { captureSelectedCwdIdentity } from '../process/selected-cwd-identity.mjs';
 import { privateComponent, PROJECT_PRIVATE_COMPONENT_WORKER_SOURCE,
-  runPinnedDirectoryWorker } from './project-files.mjs';
+  runPinnedDirectoryWorker, assertProjectFileReadsAvailable } from './project-files.mjs';
 
 const contextIgnored = new Set(['.git', 'node_modules', '.hcc', '.hello-cc', '.codex', '.claude', '.dsh', '.ssh', '.aws', 'dist', 'build', 'coverage', '.next']);
 
@@ -17,90 +15,6 @@ function assertBoundRoot(rootIdentity) {
   rootIdentity.assertUnchanged();
 }
 
-function sameDirectory(left, right) {
-  return left.isDirectory() && right.isDirectory() && left.dev === right.dev &&
-    left.ino === right.ino && left.mode === right.mode && left.size === right.size &&
-    left.mtimeNs === right.mtimeNs && left.ctimeNs === right.ctimeNs;
-}
-
-// Windows cannot use the POSIX pinned helper, so keep the existing read-only
-// traversal there. Its transient ancestor-replacement risk is not closed here.
-async function listContextFilesByPath(root, query, { limit, maxEntries, timeBudgetMs, now, rootIdentity }) {
-  assertBoundRoot(rootIdentity);
-  const base = await fs.realpath(root), pending = [''], paths = [], needle = query.toLocaleLowerCase();
-  const directorySnapshots = [];
-  if (rootIdentity) {
-    const parent = path.dirname(base);
-    directorySnapshots.push({ directory: parent, stat: await fs.lstat(parent, { bigint: true }) });
-    const initial = await fs.lstat(base, { bigint: true });
-    assertBoundRoot(rootIdentity);
-    if (rootIdentity.identity.dev !== initial.dev.toString() ||
-        rootIdentity.identity.ino !== initial.ino.toString() ||
-        rootIdentity.identity.birthtimeNs !== (initial.birthtimeNs?.toString() || null)) throw changed();
-    directorySnapshots.push({ directory: base, stat: initial });
-  }
-  const exact = await exactContextFile(base, query, rootIdentity);
-  if (exact) paths.push(exact);
-  let seen = 0, truncated = false;
-  const deadline = now() + timeBudgetMs;
-  outer: while (pending.length) {
-    if (now() >= deadline || seen >= maxEntries || paths.length >= limit) { truncated = true; break; }
-    assertBoundRoot(rootIdentity);
-    const relative = pending.shift(), directory = path.join(base, relative);
-    try {
-      const before = await fs.lstat(directory, { bigint: true });
-      if (before.isSymbolicLink() || !before.isDirectory()) continue;
-      if (rootIdentity) directorySnapshots.push({ directory, stat: before });
-      const resolved = await fs.realpath(directory), fromRoot = path.relative(base, resolved);
-      if (fromRoot === '..' || fromRoot.startsWith('..' + path.sep) || path.isAbsolute(fromRoot)) continue;
-      const handle = await fs.opendir(directory);
-      for await (const item of handle) {
-        seen++;
-        if (seen > maxEntries || now() >= deadline) { truncated = true; break outer; }
-        if (item.isSymbolicLink() || contextIgnored.has(item.name) || privateComponent(item.name) ||
-            /[\\:\x00-\x1f\x7f]/.test(item.name)) continue;
-        const name = relative ? relative + '/' + item.name : item.name;
-        if (item.isDirectory()) pending.push(name);
-        else if (item.isFile() && name !== exact && name.toLocaleLowerCase().includes(needle)) {
-          paths.push(name);
-          if (paths.length >= limit) { truncated = true; break outer; }
-        }
-      }
-      if (rootIdentity && !sameDirectory(before, await fs.lstat(directory, { bigint: true }))) throw changed();
-    } catch (error) { if (!['ENOENT', 'ENOTDIR', 'EACCES', 'EPERM'].includes(error.code)) throw error; }
-  }
-  assertBoundRoot(rootIdentity);
-  if (rootIdentity) {
-    for (const { directory, stat } of directorySnapshots) {
-      if (!sameDirectory(stat, await fs.lstat(directory, { bigint: true }))) throw changed();
-    }
-  }
-  return { paths: paths.sort(), truncated };
-}
-
-async function exactContextFile(base, query, rootIdentity) {
-  const parts = query.split('/');
-  if (!query || parts.some(part => !part || part === '.' || contextIgnored.has(part) || privateComponent(part))) return null;
-  let directory = base;
-  try {
-    for (let index = 0; index < parts.length; index++) {
-      assertBoundRoot(rootIdentity);
-      const target = path.join(directory, parts[index]), stat = await fs.lstat(target);
-      if (stat.isSymbolicLink() || (index < parts.length - 1 ? !stat.isDirectory() : !stat.isFile())) return null;
-      const resolved = await fs.realpath(target), relative = path.relative(base, resolved);
-      if (relative === '..' || relative.startsWith('..' + path.sep) || path.isAbsolute(relative) ||
-          relative.split(path.sep).some(part => contextIgnored.has(part) || privateComponent(part))) return null;
-      // Recheck the named entry after resolving it and discard any observed
-      // link or entry replacement before offering the filename.
-      const confirmed = await fs.lstat(target);
-      if (confirmed.isSymbolicLink() || confirmed.dev !== stat.dev || confirmed.ino !== stat.ino) return null;
-      directory = resolved;
-      if (index === parts.length - 1) return relative.split(path.sep).join('/');
-    }
-  } catch (error) { if (!['ENOENT', 'ENOTDIR', 'EACCES', 'EPERM'].includes(error.code)) throw error; }
-  return null;
-}
-
 function contextListWorker() {
   const fs = require('node:fs');
   const { query, limit, maxEntries, timeBudgetMs } = JSON.parse(process.argv[1]);
@@ -206,8 +120,7 @@ export async function listContextFiles(root, query = '', { limit = 80, maxEntrie
   if (!Number.isSafeInteger(limit) || limit < 1 || !Number.isSafeInteger(maxEntries) || maxEntries < 1 || !Number.isFinite(timeBudgetMs) || timeBudgetMs < 0 || typeof now !== 'function') {
     throw new TypeError('Invalid context file listing budget');
   }
-  if (process.platform === 'win32') return listContextFilesByPath(root, query,
-    { limit, maxEntries, timeBudgetMs, now, rootIdentity });
+  assertProjectFileReadsAvailable();
   const ownedIdentity = rootIdentity ? null : captureSelectedCwdIdentity(root);
   const identity = rootIdentity || ownedIdentity;
   try {

package/lib/web/http-routes.mjs

@@ -235,12 +235,12 @@ export function createHttpRoutes(deps) {
       const safeMethod = ['GET', 'HEAD', 'OPTIONS'].includes(req.method || '');
       // Cookie-authenticated writes require affirmative same-origin evidence;
       // a missing Origin is not sufficient. Token-authenticated CLI requests
-      // without cookies remain origin-free, as do tokenless loopback CLI
-      // requests; a supplied Origin on the tokenless runtime must still match.
+      // without cookies may omit Origin, as may tokenless loopback CLI
+      // requests. Any supplied Origin must match, including with a Bearer token.
       const cookieAuthenticated = authMode === 'cookie' || cookieSessionOk(req);
-      const originRequired = cookieAuthenticated || (!token && Boolean(req.headers.origin));
+      const originRequired = cookieAuthenticated || Boolean(req.headers.origin);
       if (!safeMethod && originRequired && !requestOriginMatches(req, { trustProxy, proxyOrigin })) {
-        sendJson(res, 403, { ok: false, error: { code: 'CSRF_ORIGIN', message: 'Cookie-authenticated writes require a same-origin request' } });
+        sendJson(res, 403, { ok: false, error: { code: 'CSRF_ORIGIN', message: 'Writes with cookies or Origin require a same-origin request' } });
         return;
       }
       if (req.method === 'POST' && url.pathname === '/logout') {

package/lib/web/native-sessions.mjs

@@ -591,7 +591,16 @@ export function createNativeSessions({ sessions, sessionKey, connectWebProject,
             }
             let saved;
             try { saved = JSON.parse(previous.payload); } catch { /* Reject below. */ }
-            if (!saved || Object.keys(pending).some(key => saved[key] !== pending[key])) {
+            // A fresh Claude query receives its session ID on its first input.
+            // The initial durable intent can therefore precede that ID. A
+            // fenced read above has confirmed the current provider session;
+            // allow this one-way confirmation only for the same owned executor.
+            // All other identity/body fields still have to match exactly.
+            const initializedClaude = saved?.provider === 'claude' && pending.provider === 'claude' &&
+              saved.provider_session_id === null && typeof pending.provider_session_id === 'string' &&
+              pending.provider_session_id.length > 0;
+            if (!saved || Object.keys(pending).some(key => saved[key] !== pending[key] &&
+                !(key === 'provider_session_id' && initializedClaude))) {
               throw new CliError('NATIVE_SUBMISSION_MISMATCH', 'Retry must keep the original worker, executor and message');
             }
           } else {

package/lib/web/project-files.mjs

@@ -30,11 +30,22 @@ const media = new Map([['.png', 'image/png'], ['.jpg', 'image/jpeg'], ['.jpeg',
 const errorStatus = new Map([['PROJECT_FILE_BAD_PATH', 400], ['PROJECT_FILE_FORBIDDEN', 403],
   ['PROJECT_FILE_NOT_FOUND', 404], ['PROJECT_FILE_CHANGED', 409], ['PROJECT_FILE_TOO_LARGE', 413],
   ['PROJECT_FILE_CONFLICT', 409], ['PROJECT_FILE_EXISTS', 409],
+  ['PROJECT_FILE_READ_UNAVAILABLE', 503],
   ['PROJECT_FILE_WRITE_UNCONFIRMED', 503], ['PROJECT_FILE_WRITE_UNAVAILABLE', 503],
   ['PROJECT_FILE_NOT_DIRECTORY', 400], ['PROJECT_FILE_NOT_REGULAR', 400], ['PROJECT_FILE_UNAVAILABLE', 500]]);
 
 export function projectFileErrorStatus(error) { return errorStatus.get(error?.code); }
 
+// Native Windows is unsupported (use WSL). Its path-based fallback cannot
+// protect against transient ancestor replacement. Refuse before any lookup,
+// including callers that supply an already-captured project identity.
+export function assertProjectFileReadsAvailable() {
+  if (!['darwin', 'linux'].includes(process.platform) || !constants.O_NOFOLLOW || !constants.O_DIRECTORY) {
+    throw new CliError('PROJECT_FILE_READ_UNAVAILABLE',
+      'Safe project file access requires Linux or macOS; on Windows run HCC inside WSL');
+  }
+}
+
 export function privateComponent(name) {
   const lower = name.toLowerCase();
   return ignored.has(lower) || privateNames.has(lower) || /^\.hcc-file-write-/.test(lower) || /^(?:\.?env)(?:[._-]|$)/.test(lower) ||
@@ -154,30 +165,6 @@ export const PROJECT_PRIVATE_COMPONENT_WORKER_SOURCE = `const ignored = new Set(
 const PROJECT_LIST_WORKER_SOURCE = PROJECT_PRIVATE_COMPONENT_WORKER_SOURCE +
   `(${projectListWorker.toString()})()`;
 
-// Windows has no trusted pinned-cwd launch. Keep its existing read-only
-// listing behavior; transient ancestor replacement remains outside this POSIX fix.
-async function listProjectFilesByPath(snapshot) {
-  let directory;
-  try {
-    directory = await fs.opendir(snapshot.absolute);
-    const entries = [];
-    let scanned = 0, truncated = false;
-    for await (const item of directory) {
-      if (++scanned > PROJECT_FILE_LIMITS.scannedEntries) { truncated = true; break; }
-      if (privateComponent(item.name) || /[\\:\x00-\x1f\x7f]/.test(item.name) || item.isSymbolicLink()) continue;
-      if (!item.isDirectory() && !item.isFile()) continue;
-      let stat;
-      try { stat = await fs.lstat(path.join(snapshot.absolute, item.name), { bigint: true }); }
-      catch (error) { if (error.code === 'ENOENT') throw changed(); throw error; }
-      if (stat.isSymbolicLink() || (!stat.isDirectory() && (!stat.isFile() || stat.nlink !== 1n))) continue;
-      entries.push({ name: item.name, type: stat.isDirectory() ? 'directory' : 'file',
-        ...(stat.isFile() ? { size: Number(stat.size) } : {}) });
-    }
-    directory = null;
-    return { entries, truncated };
-  } finally { await directory?.close().catch(() => {}); }
-}
-
 async function inspectPath(root, parts, directory, rootIdentity) {
   assertBoundRoot(rootIdentity);
   const base = await fs.realpath(root), chain = [];
@@ -215,6 +202,7 @@ export async function verifyProjectFileParent(snapshot, handle) { await verifyPa
 export async function prepareProjectFileParent(root, relative, { rootIdentity } = {}) {
   try {
     const parts = relativePath(relative, false);
+    assertProjectFileReadsAvailable();
     const snapshot = await inspectPath(root, parts.slice(0, -1), true, rootIdentity);
     const handle = await openChecked(snapshot, true);
     return { snapshot, handle, name: parts.at(-1) };
@@ -237,19 +225,16 @@ export async function listProjectFiles(root, relative = '', { rootIdentity } = {
   let handle, ownedIdentity;
   try {
     const parts = relativePath(relative, true);
+    assertProjectFileReadsAvailable();
     ownedIdentity = rootIdentity ? null : captureSelectedCwdIdentity(root);
     const identity = rootIdentity || ownedIdentity;
     const snapshot = await inspectPath(root, parts, true, identity);
     handle = await openChecked(snapshot, true);
-    let listing;
-    if (process.platform === 'win32') listing = await listProjectFilesByPath(snapshot);
-    else {
-      const expectedIdentity = { canonical: snapshot.absolute, identity: {
-        dev: snapshot.stat.dev.toString(), ino: snapshot.stat.ino.toString(),
-        birthtimeNs: snapshot.stat.birthtimeNs?.toString() || null } };
-      listing = await runPinnedDirectoryWorker(snapshot.absolute, expectedIdentity,
-        PROJECT_LIST_WORKER_SOURCE, { scannedEntries: PROJECT_FILE_LIMITS.scannedEntries });
-    }
+    const expectedIdentity = { canonical: snapshot.absolute, identity: {
+      dev: snapshot.stat.dev.toString(), ino: snapshot.stat.ino.toString(),
+      birthtimeNs: snapshot.stat.birthtimeNs?.toString() || null } };
+    const listing = await runPinnedDirectoryWorker(snapshot.absolute, expectedIdentity,
+      PROJECT_LIST_WORKER_SOURCE, { scannedEntries: PROJECT_FILE_LIMITS.scannedEntries });
     const entries = listing.entries.map(item => ({ ...item,
       path: relative ? relative + '/' + item.name : item.name }));
     await verifyPath(snapshot, handle);
@@ -304,7 +289,9 @@ function validMedia(bytes, mime) {
 export async function previewProjectFile(root, relative, { rootIdentity } = {}) {
   let handle;
   try {
-    const parts = relativePath(relative, false), snapshot = await inspectPath(root, parts, false, rootIdentity);
+    const parts = relativePath(relative, false);
+    assertProjectFileReadsAvailable();
+    const snapshot = await inspectPath(root, parts, false, rootIdentity);
     handle = await openChecked(snapshot, false);
     const name = parts.at(-1), size = Number(snapshot.stat.size), extension = path.extname(name).toLowerCase();
     const result = { path: relative, name, size, kind: 'unsupported', mime: 'application/octet-stream', encoding: 'base64', content: '', editable: false };
@@ -338,7 +325,9 @@ export async function previewProjectFile(root, relative, { rootIdentity } = {})
 export async function inspectProjectFileStatus(root, relative, { rootIdentity } = {}) {
   let handle;
   try {
-    const parts = relativePath(relative, false), snapshot = await inspectPath(root, parts, false, rootIdentity);
+    const parts = relativePath(relative, false);
+    assertProjectFileReadsAvailable();
+    const snapshot = await inspectPath(root, parts, false, rootIdentity);
     handle = await openChecked(snapshot, false);
     const size = Number(snapshot.stat.size);
     if (size > PROJECT_FILE_LIMITS.mediaBytes) throw new CliError('PROJECT_FILE_TOO_LARGE', 'File status reads are limited to 10 MiB');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logicseek/hello-cc",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "Local control plane for coordinating Claude Code, Codex, and other coding CLI sessions.",
   "type": "module",
   "bin": {

package/scripts/claude-fork-acceptance.mjs

@@ -0,0 +1,202 @@
+// Actual SDK, CLI subprocess and production adapter; optional local Messages
+// fixture isolates transcript/fork behavior from model recall and credentials.
+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 { createRequire } from 'node:module';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { setTimeout as delay } from 'node:timers/promises';
+import { createClaudeAdapter } from '../lib/integrations/native/claude.mjs';
+import { redactSecrets } from '../lib/shared/redact.mjs';
+
+const args = process.argv.slice(2);
+if (args.includes('--help') || (!args.includes('--fixture') && !args.includes('--run-live'))) {
+  console.log('Usage: node scripts/claude-fork-acceptance.mjs --fixture|--run-live [--claude-package DIR] [--output FILE]');
+  console.log('--fixture uses a local Messages server, no model or credentials. --run-live copies existing model routing/auth into a private provider home and consumes quota.');
+  process.exit(0);
+}
+const flags = new Set(['--fixture', '--run-live']), values = new Set(['--claude-package', '--output']);
+const options = new Map();
+for (let index = 0; index < args.length; index++) {
+  const name = args[index];
+  assert.ok(!options.has(name) && (flags.has(name) || values.has(name)), 'Unknown or repeated option');
+  if (flags.has(name)) options.set(name, true);
+  else { assert.ok(args[index + 1] && !args[index + 1].startsWith('--'), 'Missing option value'); options.set(name, args[++index]); }
+}
+assert.notEqual(Boolean(options.get('--fixture')), Boolean(options.get('--run-live')), 'Select exactly one mode');
+assert.ok(['linux', 'darwin'].includes(process.platform), 'Run inside Linux, macOS or WSL');
+const live = Boolean(options.get('--run-live'));
+const repo = fileURLToPath(new URL('..', import.meta.url));
+const output = path.resolve(options.get('--output') || path.join(os.tmpdir(), 'hcc-claude-fork-' + randomUUID() + '.json'));
+const sandbox = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'hcc-claude-fork-')));
+fs.chmodSync(sandbox, 0o700);
+const root = path.join(sandbox, 'project'), home = path.join(sandbox, 'home'), providerHome = path.join(home, '.claude');
+for (const directory of [root, home, providerHome]) fs.mkdirSync(directory, { mode: 0o700 });
+const hash = value => createHash('sha256').update(value).digest('hex');
+const digest = file => hash(fs.readFileSync(file));
+const sourceFiles = Object.fromEntries(['scripts/claude-fork-acceptance.mjs', 'lib/integrations/native/claude.mjs',
+  'lib/integrations/native/interactions.mjs', 'lib/process/selected-cwd-identity.mjs'].map(name => [name, digest(path.join(repo, name))]));
+const originalEnv = { HOME: process.env.HOME, CLAUDE_CONFIG_DIR: process.env.CLAUDE_CONFIG_DIR };
+const settings = path.join(originalEnv.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude'), 'settings.json');
+const protectedBefore = fs.existsSync(settings) ? digest(settings) : null;
+const report = { schemaVersion: 1, startedAt: new Date().toISOString(), sourceFiles,
+  mode: live ? 'real configured model' : 'deterministic local Messages fixture; actual SDK and CLI subprocess',
+  modelCallsRequested: live, realModelCalls: false, queryInjected: false, checks: [], snapshots: [], requests: [], cleanup: {}, success: false,
+  limitations: ['Adapter/SDK transcript and recall acceptance; native service ownership guards are covered separately.',
+    'A successful routed model call establishes only the model actually reported, not Anthropic model acceptance.'] };
+const flush = () => { fs.mkdirSync(path.dirname(output), { recursive: true }); fs.writeFileSync(output, JSON.stringify(redactSecrets(report), null, 2) + '\n', { mode: 0o600 }); };
+const check = name => { report.checks.push(name); console.log('PASS ' + name); flush(); };
+const adapters = [], observations = new Map();
+let server, sdk;
+function adapter(name) {
+  const events = [];
+  const value = createClaudeAdapter({ cwd: root, env: { ...process.env, HCC_SHIM_ENSURED: '1', HCC_SHIM_NO_ATTACH: '1' },
+    executorId: randomUUID(), timeoutMs: 15000,
+    onEvent(event) {
+      if (event.type === 'metadata') report.reportedModel = event.runtimeMetadata?.model || report.reportedModel;
+      if (event.type === 'completed') events.push({ type: event.type, turnId: event.turnId, status: event.status, text: event.text });
+    } });
+  adapters.push({ name, value }); observations.set(value, events); return value;
+}
+async function turn(value, prompt, expected) {
+  const sent = await value.send({ text: prompt, submissionId: randomUUID() });
+  const deadline = Date.now() + 90000;
+  let completion;
+  while (!(completion = observations.get(value).find(event => event.turnId === sent.turnId)) && Date.now() < deadline) {
+    const state = value.snapshot();
+    assert.equal(state.pendingApprovals?.length || 0, 0, 'Nonce-only fork test must never approve tools');
+    assert.ok(!state.error, 'Unexpected SDK error during fork acceptance');
+    await delay(50);
+  }
+  assert.ok(completion, 'Fork acceptance turn timed out');
+  if (live) report.realModelCalls = true;
+  assert.equal(completion.status, 'completed');
+  // Persist a non-sensitive actual/expected digest even when the assertion fails.
+  report.lastTurn = { sessionId: value.snapshot().sessionId, turnId: sent.turnId,
+    actualSha256: hash(completion.text || ''), expectedSha256: hash(expected), matches: completion.text?.trim() === expected };
+  flush(); assert.equal(completion.text?.trim(), expected);
+}
+async function history(sessionId, label) {
+  const messages = (await sdk.getSessionMessages(sessionId, { dir: root })).filter(message => ['user', 'assistant'].includes(message.type));
+  const snapshot = { label, sessionId, messages: messages.length,
+    contentHashes: messages.map(message => hash(JSON.stringify({ type: message.type, message: message.message }))),
+    messageIds: messages.map(message => message.uuid) };
+  report.snapshots.push(snapshot); flush(); return snapshot;
+}
+async function assertCopied(parentId, childId, label) {
+  // Capture both immediately after fork and before the child's first query.
+  const parent = await history(parentId, label + ': parent'), child = await history(childId, label + ': child before first query');
+  assert.ok(parent.messages >= 2, 'Parent transcript must include the seed turn');
+  assert.deepEqual(child.contentHashes, parent.contentHashes, 'Fork must copy the whole parent history before recall');
+  check(label + ': complete parent/child transcript copy before first child query');
+}
+function fixtureText(messages) {
+  const users = messages.filter(message => message.role === 'user').map(message =>
+    typeof message.content === 'string' ? message.content : (message.content || []).filter(block => block.type === 'text').map(block => block.text).join('\n'));
+  const seed = users.join('\n').match(/HCC_FORK_SEED (HCC_BASE_[a-f0-9]+)\|(HCC_BRANCH_[a-f0-9]+)/);
+  let branch = seed?.[2];
+  for (const text of users) { const changed = /HCC_FORK_SET (HCC_BRANCH_[a-f0-9]+)/.exec(text); if (changed) branch = changed[1]; }
+  report.requests.push({ historyHasSeed: Boolean(seed), userMessages: users.length, branchSha256: branch ? hash(branch) : null });
+  return seed ? seed[1] + '|' + branch : 'MISSING_CONTEXT';
+}
+function stream(response, model, text) {
+  response.writeHead(200, { 'content-type': 'text/event-stream' });
+  const event = (type, value) => response.write('event: ' + type + '\ndata: ' + JSON.stringify({ type, ...value }) + '\n\n');
+  event('message_start', { message: { id: 'msg_' + randomUUID().replaceAll('-', ''), 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: { type: 'text', text: '' } });
+  event('content_block_delta', { index: 0, delta: { type: 'text_delta', text } });
+  event('content_block_stop', { index: 0 });
+  event('message_delta', { delta: { stop_reason: 'end_turn', stop_sequence: null }, usage: { output_tokens: 1 } });
+  event('message_stop', {}); response.end();
+}
+try {
+  if (options.get('--claude-package')) {
+    const installed = fs.realpathSync(path.resolve(options.get('--claude-package')));
+    const pkg = JSON.parse(fs.readFileSync(path.join(installed, 'package.json'), 'utf8'));
+    assert.equal(pkg.name, '@anthropic-ai/claude-agent-sdk');
+    const scope = path.join(root, 'node_modules', '@anthropic-ai'); fs.mkdirSync(scope, { recursive: true, mode: 0o700 });
+    fs.symlinkSync(installed, path.join(scope, 'claude-agent-sdk'), 'dir');
+  }
+  const entry = createRequire(path.join(root, 'package.json')).resolve('@anthropic-ai/claude-agent-sdk');
+  report.sdk = { entrySha256: digest(entry), version: JSON.parse(fs.readFileSync(path.join(path.dirname(entry), 'package.json'), 'utf8')).version };
+  process.env.HOME = home; process.env.CLAUDE_CONFIG_DIR = providerHome;
+  if (live) {
+    if (protectedBefore) {
+      const source = JSON.parse(fs.readFileSync(settings, 'utf8'));
+      const env = Object.fromEntries(Object.entries(source.env || {}).filter(([key, value]) => key.startsWith('ANTHROPIC_') && typeof value === 'string'));
+      fs.writeFileSync(path.join(providerHome, 'settings.json'), JSON.stringify({ env,
+        ...(typeof source.model === 'string' ? { model: source.model } : {}) }), { mode: 0o600 });
+    }
+  } else {
+    server = http.createServer(async (request, response) => {
+      try {
+        assert.equal(request.method, 'POST'); assert.match(request.url, /^\/v1\/messages(?:\?|$)/);
+        const chunks = []; let size = 0;
+        for await (const chunk of request) { size += chunk.length; assert.ok(size <= 2 * 1024 * 1024); chunks.push(chunk); }
+        assert.ok(report.requests.length < 10, 'Fixture request bound exceeded');
+        const body = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+        const text = fixtureText(body.messages);
+        if (body.stream) stream(response, body.model, text);
+        else { response.writeHead(200, { 'content-type': 'application/json' }); response.end(JSON.stringify({ id: 'msg_' + randomUUID(), type: 'message', role: 'assistant', model: body.model,
+          content: [{ type: 'text', text }], stop_reason: 'end_turn', stop_sequence: null, usage: { input_tokens: 1, output_tokens: 1 } })); }
+      } catch { response.writeHead(500); response.end(JSON.stringify({ error: { type: 'api_error', message: 'Fixture protocol failure' } })); }
+    });
+    await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
+    fs.writeFileSync(path.join(providerHome, 'settings.json'), JSON.stringify({ model: 'claude-sonnet-4-5-20250929', env: {
+      ANTHROPIC_BASE_URL: 'http://127.0.0.1:' + server.address().port, ANTHROPIC_API_KEY: 'local-fixture-no-credential',
+      ANTHROPIC_AUTH_TOKEN: '', CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: '1' } }), { mode: 0o600 });
+  }
+  sdk = await import(pathToFileURL(entry).href);
+  assert.equal(typeof sdk.forkSession, 'function'); assert.equal(typeof sdk.getSessionMessages, 'function');
+  const base = 'HCC_BASE_' + randomUUID().replaceAll('-', '').slice(0, 16);
+  const initial = 'HCC_BRANCH_' + randomUUID().replaceAll('-', '').slice(0, 16);
+  const changed = 'HCC_BRANCH_' + randomUUID().replaceAll('-', '').slice(0, 16);
+  const recall = 'HCC_FORK_RECALL: Without tools or reading files, reply only with the full base|branch values established earlier, including the original HCC_BASE_ and HCC_BRANCH_ prefixes and their hexadecimal suffixes. Do not infer or invent missing values.';
+  const parent = adapter('parent'); await parent.open();
+  await turn(parent, 'HCC_FORK_SEED ' + base + '|' + initial + '. Remember both complete values in this conversation. Reply with exactly this complete string including both HCC_ prefixes: ' + base + '|' + initial + '. Do not use tools or read files.', base + '|' + initial);
+  const parentId = parent.snapshot().sessionId;
+  const child = adapter('child'); await child.open({ forkSessionId: parentId });
+  const childId = child.snapshot().sessionId; assert.ok(childId && childId !== parentId);
+  await assertCopied(parentId, childId, 'open-parent fork');
+  if (!live) assert.equal(report.requests.length, 1, 'Fork must not perform hidden inference');
+  await turn(child, recall, base + '|' + initial); check('first child turn recalls both copied values without prompt replay');
+  await turn(child, 'HCC_FORK_SET ' + changed + '. Replace only the branch value, keep the original full base value, and reply only with base|branch including the HCC_BASE_ and HCC_BRANCH_ prefixes and hexadecimal suffixes. No tools or file reads.', base + '|' + changed);
+  const parentBefore = await history(parentId, 'parent after child-only branch change');
+  await turn(parent, recall, base + '|' + initial); check('child branch update leaves parent model-visible values intact');
+  const childBeforeResume = await history(childId, 'child before close/resume');
+  assert.ok(childBeforeResume.messages > parentBefore.messages);
+  await child.close();
+  const resumed = adapter('resumed-child'); await resumed.open({ sessionId: childId });
+  await turn(resumed, recall, base + '|' + changed);
+  assert.equal(resumed.snapshot().sessionId, childId); check('child close/resume retains its own identity and changed branch');
+  await parent.close();
+  const closedFork = adapter('closed-parent-child'); await closedFork.open({ forkSessionId: parentId });
+  const closedForkId = closedFork.snapshot().sessionId;
+  assert.ok(closedForkId && closedForkId !== childId && closedForkId !== parentId);
+  await assertCopied(parentId, closedForkId, 'closed-parent fork');
+  await turn(closedFork, recall, base + '|' + initial); check('closed-parent fork recalls the original branch with a distinct identity');
+  report.completed = true;
+} catch (error) {
+  report.error = { code: error.code || 'ACCEPTANCE_FAILED', message: redactSecrets(error.message).slice(0, 1500) };
+  if (sdk?.getSessionMessages) for (const { name, value } of adapters) {
+    const sessionId = value.snapshot().sessionId;
+    if (sessionId) try { await history(sessionId, 'failure: ' + name); } catch { /* Preserve earlier snapshots. */ }
+  }
+} finally {
+  const closed = await Promise.allSettled(adapters.map(({ value }) => value.close()));
+  report.cleanup.adaptersClosed = closed.every(value => value.status === 'fulfilled');
+  if (server) { server.closeAllConnections(); await new Promise(resolve => server.close(resolve)); }
+  for (const [key, value] of Object.entries(originalEnv)) { if (value === undefined) delete process.env[key]; else process.env[key] = value; }
+  report.protectedSettingsUnchanged = protectedBefore === null ? !fs.existsSync(settings) : fs.existsSync(settings) && digest(settings) === protectedBefore;
+  report.sourceChanges = Object.entries(sourceFiles).filter(([name, before]) => digest(path.join(repo, name)) !== before).map(([name]) => name);
+  try { fs.rmSync(sandbox, { recursive: true, force: true }); report.cleanup.privateProjectAndHomeRemoved = !fs.existsSync(sandbox); }
+  catch { report.cleanup.privateProjectAndHomeRemoved = false; }
+  report.success = report.completed === true && !report.error && report.cleanup.adaptersClosed && report.cleanup.privateProjectAndHomeRemoved && report.protectedSettingsUnchanged && !report.sourceChanges.length;
+  report.finishedAt = new Date().toISOString(); flush();
+}
+console.log(JSON.stringify({ output, success: report.success, realModelCalls: report.realModelCalls, checks: report.checks.length, error: report.error, cleanup: report.cleanup }));
+process.exitCode = report.success ? 0 : 1;