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

package/lib/cli/commands/hook.mjs

@@ -4,6 +4,8 @@
 import { parseOpts, validateOpts } from '../../cli-args.mjs';
 import { tx } from '../../db/schema.mjs';
 import { resolveProjectDatabase } from '../../runtime/project-path.mjs';
+import { projectDbPath } from '../../runtime/paths.mjs';
+import { HOOK_ROOT_IDENTITY_ENV, assertHookRootIdentity } from '../../core/sessions/hook-root-identity.mjs';
 
 export function createHookCommand(deps) {
   const {
@@ -85,21 +87,34 @@ async function cmdHook(ctx, args) {
   const hccRoot = (nativeOwner || !isDsh) && process.env.HCC_ROOT
     ? path.resolve(process.env.HCC_ROOT)
     : path.resolve(hookCwd);
+  // First-party launches carry the original directory inode. Reject a stale
+  // callback before database resolution or project activity can target a new
+  // directory installed at the old pathname. dsh service hooks are intentionally
+  // payload-scoped and do not inherit a service-wide project identity.
+  const launchRootIdentity = (!isDsh || nativeOwner)
+    ? assertHookRootIdentity(hccRoot, process.env[HOOK_ROOT_IDENTITY_ENV]) : null;
 
   const dshProject = isDsh && !nativeOwner ? resolveProjectDatabase({ root: hccRoot, createStateDir: false }) : null;
   const nativeProject = nativeOwner ? resolveProjectDatabase({ root: hccRoot,
     db: process.env.HCC_DB, createStateDir: false }) : null;
-  const ordinaryDb = (ctx.root && path.resolve(ctx.root) === hccRoot ? ctx.dbPath : null) ||
+  const sameHookRoot = () => {
+    if (!ctx.root) return false;
+    try { return fs.realpathSync(ctx.root) === fs.realpathSync(hccRoot); }
+    catch { return path.resolve(ctx.root) === hccRoot; }
+  };
+  const ordinaryDb = (sameHookRoot() ? ctx.dbPath : null) ||
     process.env.HCC_DB;
   if (nativeProject && !fs.existsSync(nativeProject.db)) {
     throw new CliError('NATIVE_HOOK_OWNERSHIP_MISMATCH', 'Native hook database must already be owned by its runtime');
   }
+  const ordinaryDefaultDb = !dshProject && !nativeProject && !ordinaryDb
+    ? projectDbPath(hccRoot) : null;
   const hookCtx = {
     ...ctx,
     root: nativeProject?.root || dshProject?.root || hccRoot,
-    dbPath: nativeProject?.db || dshProject?.db || (ordinaryDb ? path.resolve(ordinaryDb) : path.join(hccRoot, '.hello-cc', 'mesh.db'))
+    dbPath: nativeProject?.db || dshProject?.db || ordinaryDefaultDb || path.resolve(ordinaryDb),
+    ...(launchRootIdentity ? { initialRootIdentity: launchRootIdentity } : {})
   };
-  if (!nativeOwner) registerProjectActivity(hookCtx);
 
   // dsh uses only its true session ID. Ordinary hooks retain environment,
   // resume, session, and terminal identity precedence.
@@ -120,6 +135,7 @@ async function cmdHook(ctx, args) {
   // Hook delivery must not migrate another workspace's registered database.
   const db = isDsh || nativeOwner ? connect(hookCtx, { migrateRegistered: false }) : connect(hookCtx);
   try {
+    if (!nativeOwner) registerProjectActivity(hookCtx);
     if (nativeOwner) {
       // Native delivery owns context injection and completion receipts. Hooks
       // only renew its verified owner, never turn a native binding into a

package/lib/cli/commands/install.mjs

@@ -1,17 +1,23 @@
 // Install/setup/update/uninstall/shim commands extracted from bin/hcc.mjs.
 
 import { execFileSync, spawnSync } from 'node:child_process';
+import { secureExistingProjectStateDirectory } from '../../runtime/project-path.mjs';
+import { legacyProjectStateDir, projectStateDir } from '../../runtime/paths.mjs';
+import { privateProjectStateDir, inspectPrivateProjectAuthority,
+  purgePrivateProjectState } from '../../runtime/private-state.mjs';
+import { captureSelectedCwdIdentity } from '../../process/selected-cwd-identity.mjs';
+import { purgePinnedLegacyProjectState } from '../../process/pinned-project-state.mjs';
 
 export function createInstallCommands(deps) {
   const {
     path, fs, process, CliError, parseOpts, validateOpts, wantsHelp,
     printResult, commandPath, connect, readRuntime, runtimeRequest,
-    runtimePath, globalRuntimePath, PRODUCT_NAME, VERSION, NPM_PACKAGE_NAME,
+    globalRuntimePath, PRODUCT_NAME, VERSION, NPM_PACKAGE_NAME,
     helpInstallHooks, helpShim, helpUninstall, helpUpdate,
     loadSetup, shellCommand,
 
 
-    sameResolvedPath, writeGuidance, removeGuidanceBlocks,
+    sameResolvedPath, writeGuidance, removeGuidanceBlocks, spawnPinnedStateProcess,
   
   } = deps;
 
@@ -236,14 +242,48 @@ async function cmdUninstall(ctx, args) {
   if (opts.purge && !opts.yes) {
     throw new CliError('CONFIRM_REQUIRED', 'Refusing to purge project data without --yes');
   }
+  const selectedRoot = opts.purge ? captureSelectedCwdIdentity(ctx.root) : null;
+  let selectedLegacyState = null;
+  try {
+  // Resolve before changing hooks, guidance, or runtime state. An unsafe root
+  // with unmigrated legacy data must not be treated as an empty private store.
+  let purgeStateDir = null;
+  let purgeIsLegacy = false;
+  let missingPrivateState = false;
+  if (opts.purge) {
+    try {
+      const resolved = secureExistingProjectStateDirectory(ctx.root);
+      purgeStateDir = resolved.stateDir;
+      purgeIsLegacy = path.resolve(purgeStateDir) === path.join(selectedRoot.canonical, '.hello-cc');
+      if (purgeIsLegacy && resolved.exists) {
+        selectedLegacyState = captureSelectedCwdIdentity(purgeStateDir);
+        selectedRoot.assertUnchanged();
+      }
+    } catch (error) {
+      if (projectStateDir(ctx.root) !== privateProjectStateDir(ctx.root)) throw error;
+      const recoverablePending = error?.code === 'STATE_MIGRATION_REQUIRED' &&
+        inspectPrivateProjectAuthority(ctx.root) === 'pending';
+      if (!['STATE_AUTHORITY_MISSING', 'STATE_PURGE_INCOMPLETE'].includes(error?.code) &&
+          !recoverablePending) throw error;
+      purgeStateDir = privateProjectStateDir(ctx.root);
+      missingPrivateState = true;
+    }
+  }
 
   const lines = [];
 
   let runtime = null;
-  try {
-    runtime = readRuntime(ctx);
-  } catch (err) {
-    if (!(err instanceof CliError && err.code === 'RUNTIME_NOT_RUNNING')) throw err;
+  let runtimePointer = null;
+  if (!missingPrivateState) {
+    // Keep the validated state route fixed across the asynchronous stop probe.
+    // Re-deriving it afterwards could remove another project's pointer if a
+    // user-supplied root alias is retargeted in the meantime.
+    runtimePointer = path.join(secureExistingProjectStateDirectory(ctx.root).stateDir, 'runtime.json');
+    try {
+      runtime = readRuntime(ctx);
+    } catch (err) {
+      if (!(err instanceof CliError && err.code === 'RUNTIME_NOT_RUNNING')) throw err;
+    }
   }
   if (runtime) {
     try {
@@ -251,7 +291,7 @@ async function cmdUninstall(ctx, args) {
       lines.push('runtime stopped');
     } catch (err) {
       if (!(err instanceof CliError && err.code === 'RUNTIME_UNREACHABLE')) throw err;
-      try { fs.rmSync(runtimePath(ctx), { force: true }); } catch {}
+      try { fs.rmSync(runtimePointer, { force: true }); } catch {}
       lines.push('stale runtime file removed');
     }
   } else {
@@ -259,6 +299,7 @@ async function cmdUninstall(ctx, args) {
   }
 
   const { uninstallClaudeHooks, uninstallCodexHooks, uninstallShims, uninstallPathEntry } = await loadSetup();
+  selectedRoot?.assertUnchanged();
   const claude = uninstallClaudeHooks();
   const codex = uninstallCodexHooks();
   const shims = uninstallShims();
@@ -271,11 +312,36 @@ async function cmdUninstall(ctx, args) {
   let guidance = [];
   let purged = false;
   if (opts.purge) {
-    guidance = removeGuidanceBlocks(ctx);
+    guidance = removeGuidanceBlocks(ctx, { expectedBinding: selectedRoot });
     try {
-      fs.rmSync(path.join(ctx.root, '.hello-cc'), { recursive: true, force: true });
+      selectedRoot.assertUnchanged();
+      if (!purgeIsLegacy) {
+        // Revalidate and delete under the same transition lock used by init
+        // and migration. An interrupted deletion remains marked purging.
+        purgeStateDir = purgePrivateProjectState(ctx.root);
+      } else {
+        // Async shutdown and hook removal happened after the initial lookup.
+        // Refuse a stale legacy target if project-state routing changed.
+        const current = secureExistingProjectStateDirectory(ctx.root);
+        if (path.resolve(current.stateDir) !== path.resolve(purgeStateDir)) {
+          throw new CliError('PROJECT_PATH_FORBIDDEN', 'Project state route changed during uninstall');
+        }
+        if (selectedLegacyState) {
+          purgePinnedLegacyProjectState(ctx.root, purgeStateDir, selectedRoot, selectedLegacyState,
+            { spawnProcess: spawnPinnedStateProcess });
+        } else if (current.exists) {
+          throw new CliError('PROJECT_PATH_FORBIDDEN', 'Project state appeared during uninstall');
+        }
+      }
       purged = true;
-      lines.push(`project data removed: ${path.join(ctx.root, '.hello-cc')}`);
+      lines.push(`project data removed: ${purgeStateDir}`);
+      const legacyDir = legacyProjectStateDir(ctx.root);
+      if (path.resolve(legacyDir) !== path.resolve(purgeStateDir) && fs.existsSync(legacyDir)) {
+        lines.push(`legacy project data kept: ${legacyDir}`);
+        lines.push('private authority kept; future use requires an explicit offline migration of the legacy source');
+      } else if (path.resolve(legacyDir) !== path.resolve(purgeStateDir)) {
+        lines.push('private authority kept; a fresh init can now create new private state');
+      }
     } catch (err) {
       throw new CliError('PURGE_FAILED', `Could not remove .hello-cc: ${err.message}`);
     }
@@ -285,6 +351,10 @@ async function cmdUninstall(ctx, args) {
   }
 
   printResult(ctx, { runtime: Boolean(runtime), claude, codex, shims, path_entry: pathEntry, purge: purged, guidance }, () => lines.join('\n'));
+  } finally {
+    selectedLegacyState?.release();
+    selectedRoot?.release();
+  }
 }
 
 // ─── hcc scan ────────────────────────────────────────────────────────────────

package/lib/cli/commands/misc.mjs

@@ -1,4 +1,6 @@
 // Small utility commands extracted from bin/hcc.mjs: down, find-root, which-real.
+import { performance } from 'node:perf_hooks';
+import { resolveProjectDatabase } from '../../runtime/project-path.mjs';
 
 export function createMiscCommands(deps) {
   const {
@@ -54,7 +56,24 @@ export function createMiscCommands(deps) {
 
   async function cmdDown(ctx, args) {
     if (args[0] === '--help' || args[0] === '-h') return helpDown();
-    const pointerFiles = [runtimePath(ctx), globalRuntimePath()];
+    const stopStartedAt = performance.now();
+    const elapsedSince = (startedAt) => Math.max(0, Math.round(performance.now() - startedAt));
+    function stopFailure(error, phase, state = 'unknown', confirmationMs = null) {
+      // Retain the original error and transport context. Only fixed phase/state
+      // vocabulary and monotonic durations describe the local confirmation.
+      error.extra = {
+        ...error.extra,
+        stopPhase: phase,
+        state: ['live', 'dead', 'unknown'].includes(state) ? state : 'unknown',
+        stopElapsedMs: elapsedSince(stopStartedAt),
+        ...(confirmationMs === null ? {} : { confirmationMs })
+      };
+      return error;
+    }
+    const localPointer = ctx.root
+      ? path.join(resolveProjectDatabase({ root: ctx.root, createStateDir: false }).stateDir, 'runtime.json')
+      : runtimePath(ctx);
+    const pointerFiles = [localPointer, globalRuntimePath()];
     let runtime;
     try {
       runtime = readRuntime(ctx);
@@ -71,13 +90,16 @@ export function createMiscCommands(deps) {
       await runtimeRequest(ctx, 'POST', '/api/runtime/stop', {}, runtime);
     } catch (err) {
       if (!(err instanceof CliError && err.code === 'RUNTIME_UNREACHABLE')) throw err;
-      if (!stopEvidence) throw err;
+      if (!stopEvidence) throw stopFailure(err, 'evidence_unavailable');
+      const confirmationStartedAt = performance.now();
       const stopped = await waitForProcessIdentityExit(stopEvidence.owner, {
         timeoutMs: 5_000,
         intervalMs: 25
       });
-      if (stopped.state !== 'dead') throw err;
+      const confirmationMs = elapsedSince(confirmationStartedAt);
+      if (stopped.state !== 'dead') throw stopFailure(err, 'exit_unconfirmed', stopped.state, confirmationMs);
       let cleanup;
+      let cleanupPhase = 'pointer_cleanup_failed';
       try {
         cleanup = withFileLock(stopEvidence.source, (file) => {
           let current;
@@ -86,7 +108,10 @@ export function createMiscCommands(deps) {
             if (error.code === 'ENOENT') return { reclaimed: 0, blocked: false };
             throw error;
           }
-          if (!sameStopPointer(stopEvidence.pointer, current)) throw err;
+          if (!sameStopPointer(stopEvidence.pointer, current)) {
+            cleanupPhase = 'pointer_changed';
+            throw err;
+          }
           // Hold the pointer's existing lock across comparison and reclamation.
           // A replacement owner must never be removed by this stop request.
           return reclaimRuntimePointerFiles([file], {
@@ -94,8 +119,8 @@ export function createMiscCommands(deps) {
             withLock: (_file, operation) => operation(file)
           });
         }, { createParent: false });
-      } catch { throw err; }
-      if (cleanup.blocked || cleanup.reclaimed > 1) throw err;
+      } catch { throw stopFailure(err, cleanupPhase, 'dead', confirmationMs); }
+      if (cleanup.blocked || cleanup.reclaimed > 1) throw stopFailure(err, 'pointer_cleanup_failed', 'dead', confirmationMs);
       printResult(ctx, { runtime: stopEvidence.source }, () => cleanup.reclaimed === 1
         ? `${PRODUCT_NAME} stale runtime pointer removed`
         : `${PRODUCT_NAME} runtime stopped`);
@@ -103,16 +128,18 @@ export function createMiscCommands(deps) {
     }
     if (runtime.source !== 'env') {
       const processIdentity = runtime.process_identity || runtime.processIdentity || runtime.pid;
+      const confirmationStartedAt = performance.now();
       const stopped = await waitForProcessIdentityExit(processIdentity, {
         timeoutMs: 5_000,
         intervalMs: 25
       });
+      const confirmationMs = elapsedSince(confirmationStartedAt);
       if (stopped.state !== 'dead') {
-        throw new CliError(
+        throw stopFailure(new CliError(
           'RUNTIME_STOP_TIMEOUT',
           `Runtime accepted the stop request, but process ${runtime.pid || 'unknown'} did not exit within 5s.`,
-          { pid: runtime.pid || null, state: stopped.state }
-        );
+          { pid: runtime.pid || null }
+        ), 'exit_unconfirmed', stopped.state, confirmationMs);
       }
     }
     printResult(ctx, { runtime: runtime.source || runtime.base_url }, () => `${PRODUCT_NAME} runtime stopped`);

package/lib/cli/commands/native.mjs

@@ -1,12 +1,9 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { spawn } from 'node:child_process';
-import { setTimeout as delay } from 'node:timers/promises';
 import { CliError } from '../../shared/errors.mjs';
 import { parseOpts, validateOpts, wantsHelp, intOpt } from '../../cli-args.mjs';
 import { printResult } from '../../format.mjs';
-import { commandPath } from '../../cli-runtime.mjs';
-import { nativePaths, readNativePointer } from '../../runtime/native/store.mjs';
+import { ensureNativeRuntime } from '../../runtime/native/launcher.mjs';
 import { nativeRequest } from '../../runtime/native/client.mjs';
 import { startNativeService } from '../../runtime/native/service.mjs';
 
@@ -29,37 +26,6 @@ dsh workers use the ACP profile, not its Web-service terminal.`);
 }
 
 export function createNativeCommands(deps) {
-  async function up(ctx) {
-    if (readNativePointer(ctx)) {
-      try { return await nativeRequest(ctx, 'GET', '/status', null, { timeoutMs: 2000 }); }
-      catch (error) {
-        if (error.code !== 'NATIVE_RUNTIME_OFFLINE') throw error;
-      }
-    }
-    const paths = nativePaths(ctx, { create: true });
-    const log = fs.openSync(paths.log, fs.constants.O_WRONLY | fs.constants.O_APPEND | fs.constants.O_CREAT | (fs.constants.O_NOFOLLOW || 0), 0o600);
-    if (!fs.fstatSync(log).isFile() || fs.fstatSync(log).nlink !== 1) {
-      fs.closeSync(log);
-      throw new CliError('NATIVE_STATE_UNSAFE', 'Native runtime log must be a private regular file');
-    }
-    const child = spawn(process.execPath, [commandPath(), '--root', fs.realpathSync(ctx.root), '--db', path.resolve(ctx.dbPath), 'native', 'serve'], {
-      cwd: ctx.root, env: process.env, detached: true, stdio: ['ignore', log, log]
-    });
-    fs.closeSync(log);
-    let failed;
-    child.on('error', (error) => { failed = error; });
-    child.unref();
-    const deadline = Date.now() + 10000;
-    while (Date.now() < deadline) {
-      if (failed) throw new CliError('NATIVE_RUNTIME_START_FAILED', failed.message);
-      if (readNativePointer(ctx)) {
-        try { return await nativeRequest(ctx, 'GET', '/status', null, { timeoutMs: 1000 }); } catch {}
-      }
-      await delay(100);
-    }
-    throw new CliError('NATIVE_RUNTIME_START_FAILED', `Native runtime did not become ready. Inspect ${paths.log}`);
-  }
-
   async function cmdNative(ctx, args) {
     const command = args[0];
     if (!command || wantsHelp(args)) return nativeHelp();
@@ -79,7 +45,7 @@ export function createNativeCommands(deps) {
     if (command === 'start' && opts.provider === 'claude' && opts.binary !== undefined) throw new CliError('BAD_ARGS', 'Claude workers use the Agent SDK; --binary is available for Codex and dsh');
     if (command === 'send' && !opts.body?.trim()) throw new CliError('BAD_ARGS', 'Missing --body');
     let result;
-    if (command === 'up') result = await up(ctx);
+    if (command === 'up') result = await ensureNativeRuntime(ctx);
     else if (command === 'serve') {
       const service = await startNativeService(ctx, deps);
       const shutdown = () => { void service.shutdown().catch((error) => console.error(JSON.stringify({ code: error.code, message: error.message }))); };
@@ -87,7 +53,7 @@ export function createNativeCommands(deps) {
       process.once('SIGINT', shutdown);
       return;
     } else if (command === 'start') {
-      await up(ctx);
+      await ensureNativeRuntime(ctx);
       result = await nativeRequest(ctx, 'POST', '/workers', { peer: opts.peer, provider: opts.provider,
         cwd: opts.cwd ? path.resolve(ctx.cwd, opts.cwd) : ctx.root, model: opts.model, binary: opts.binary, resume: opts.resume });
     } else if (command === 'send') {
@@ -113,7 +79,7 @@ export function createNativeCommands(deps) {
           const data = fs.readFileSync(path.resolve(ctx.cwd, opts['response-file']), 'utf8');
           if (data.length > 100000) throw new CliError('BAD_ARGS', 'Response file exceeds the limit');
           try { response = JSON.parse(data); } catch { throw new CliError('BAD_ARGS', 'Response file must contain JSON'); }
-          if (!response || typeof response !== 'object' || Array.isArray(response) || Object.keys(response).some(key => !['permissions','scope','answers'].includes(key))) throw new CliError('BAD_ARGS', 'Response file accepts permissions, scope and answers only');
+          if (!response || typeof response !== 'object' || Array.isArray(response) || Object.keys(response).some(key => !['permissions','scope','answers','content'].includes(key))) throw new CliError('BAD_ARGS', 'Response file accepts permissions, scope, answers and MCP content only');
         }
         const request = pending[0];
         result = await nativeRequest(ctx, 'POST', '/respond', { peer: opts.peer, generation: state.generation,

package/lib/cli/commands/peer.mjs

@@ -4,6 +4,7 @@ import {
   RUNTIME_SESSION_MUTATION_TIMEOUT_MS,
   RUNTIME_SESSION_START_TIMEOUT_MS
 } from '../../runtime/client.mjs';
+import { captureSelectedCwdSnapshot } from '../../process/selected-cwd-identity.mjs';
 
 export function createPeerCommands(deps) {
   const {
@@ -75,6 +76,7 @@ async function peerStart(ctx, args) {
   const kind = inferPeerKind(id, opts.kind, firstCommand);
   const role = opts.role || 'peer';
   const cwd = path.resolve(opts.cwd || ctx.root);
+  const cwdIdentity = captureSelectedCwdSnapshot(cwd);
   const built = buildPeerCommand(id, kind, opts, cmdArgs);
   const command = built.command;
   const binding = { ...built.binding, transport: 'tmux', runtime_session_id: id };
@@ -139,6 +141,7 @@ async function peerStart(ctx, args) {
     role,
     command,
     cwd,
+    cwdIdentity,
     binding,
     env: childSessionEnv(),
     restartOnEnvChange: Boolean(opts['restart-env']),

package/lib/cli/commands/run.mjs

@@ -6,8 +6,9 @@ import path from 'node:path';
 import fs from 'node:fs';
 import process from 'node:process';
 import { randomBytes } from 'node:crypto';
-import { spawn } from 'node:child_process';
 import { CliError } from '../../shared/errors.mjs';
+import { spawnPinnedCwdProcess, spawnPinnedCwdPty } from '../../process/pinned-cwd.mjs';
+import { captureSelectedCwdSnapshot } from '../../process/selected-cwd-identity.mjs';
 import { tx } from '../../db/schema.mjs';
 import { parseOpts, validateOpts } from '../../cli-args.mjs';
 import { runtimeProcessIdentity } from '../../runtime/state.mjs';
@@ -57,6 +58,7 @@ async function cmdRun(ctx, args) {
   const id = identity.id;
   const role = opts.role || 'peer';
   const cwd = path.resolve(opts.cwd || ctx.cwd);
+  const expectedCwdIdentity = captureSelectedCwdSnapshot(cwd);
   const command = cmdArgs.length ? cmdArgs[0] : defaultSessionCommand(kind);
   const commandArgs = cmdArgs.length ? cmdArgs.slice(1) : [];
   const binding = bindingFromRun(id, kind, command, commandArgs, 'hcc-run');
@@ -67,6 +69,7 @@ async function cmdRun(ctx, args) {
       kind,
       role,
       cwd,
+      expectedCwdIdentity,
       command,
       commandArgs,
       binding,
@@ -131,10 +134,12 @@ async function cmdRun(ctx, args) {
     db.close();
   }
   console.error(redactedLogText(`${CLI_NAME}: running ${id} (${kind}, ${role}) -> ${command} ${commandArgs.join(' ')}`.trim()));
-  const child = spawn(command, commandArgs, {
+  const child = spawnPinnedCwdProcess(command, commandArgs, {
     cwd,
+    expectedIdentity: expectedCwdIdentity,
     stdio: 'inherit',
-    env: childSessionEnv({ HCC_PEER: id, HCC_ROOT: ctx.root, HCC_DB: ctx.dbPath })
+    env: childSessionEnv({ HCC_PEER: id, HCC_ROOT: ctx.root, HCC_DB: ctx.dbPath },
+      process.env, { rootIdentity: ctx.initialRootIdentity })
   });
   const exitCode = await new Promise((resolve) => {
     child.on('exit', (code, signal) => resolve({ code, signal }));
@@ -174,7 +179,7 @@ async function cmdRun(ctx, args) {
  * the local terminal and a shared buffer file so hcc web can stream it to
  * browsers. Input from the browser is written to a .in file that we relay.
  */
-async function cmdRunWebManaged(ctx, { id, kind, role, cwd, command, commandArgs, binding, force = false }) {
+async function cmdRunWebManaged(ctx, { id, kind, role, cwd, expectedCwdIdentity, command, commandArgs, binding, force = false }) {
   registerProjectActivity(ctx);
   const ptyModule = await import('node-pty');
   const pty = ptyModule.default || ptyModule;
@@ -265,9 +270,11 @@ async function cmdRunWebManaged(ctx, { id, kind, role, cwd, command, commandArgs
   const cols = process.stdout.columns || 120;
   const rows = process.stdout.rows || 40;
 
-  const child = pty.spawn(command, commandArgs, {
+  const child = spawnPinnedCwdPty(pty, command, commandArgs, {
     name: 'xterm-256color', cols, rows, cwd,
-    env: childSessionEnv({ HCC_PEER: id, HCC_ROOT: ctx.root, HCC_DB: ctx.dbPath, TERM: 'xterm-256color' })
+    expectedIdentity: expectedCwdIdentity,
+    env: childSessionEnv({ HCC_PEER: id, HCC_ROOT: ctx.root, HCC_DB: ctx.dbPath, TERM: 'xterm-256color' },
+      process.env, { rootIdentity: ctx.initialRootIdentity })
   });
   const childExit = trackPtyExit(child);
   const wrapperTermination = installPtyTerminationHandlers(child);

package/lib/cli/commands/tmux.mjs

@@ -2,7 +2,6 @@
 // hcc scan detects provider sessions; the tmux helpers implement DB-proven,
 // evidence-checked tmux GC (plan/validate/execute) for hcc-managed sessions.
 
-import path from 'node:path';
 import process from 'node:process';
 import { spawnSync } from 'node:child_process';
 import { CliError } from '../../shared/errors.mjs';
@@ -527,7 +526,7 @@ async function planTmuxGc(ctx, opts) {
       continue;
     }
     const hccRoot = tmuxSessionEnvironmentValue(actualSession, 'HCC_ROOT');
-    if (hccRoot && path.resolve(hccRoot) !== path.resolve(ctx.root)) {
+    if (hccRoot && rootEvidence(ctx.root, hccRoot).state !== 'match') {
       skip('hcc_root_mismatch', { hcc_root: hccRoot });
       continue;
     }

package/lib/cli-runtime.mjs

@@ -2,15 +2,32 @@ import fs from 'node:fs';
 import path from 'node:path';
 import process from 'node:process';
 import { projectDbPath } from './runtime/paths.mjs';
+import { captureSelectedCwdSnapshot } from './process/selected-cwd-identity.mjs';
 
 export function createContext(global = {}, deps = {}) {
   const cwd = deps.cwd || process.cwd();
   const detectRoot = deps.detectRoot;
   if (typeof detectRoot !== 'function') throw new TypeError('createContext requires deps.detectRoot');
-  const root = detectRoot(cwd, global.root);
+  const requestedRoot = detectRoot(cwd, global.root);
+  // Freeze an existing root's canonical pathname for this command. A symlink
+  // supplied through --root (or HCC_ROOT) may be retargeted after context
+  // construction; later state and runtime path derivations must not silently
+  // switch projects. Missing roots retain their path for commands that create
+  // a project directory.
+  let root;
+  let initialRootIdentity = null;
+  try {
+    root = fs.realpathSync.native(requestedRoot);
+    initialRootIdentity = captureSelectedCwdSnapshot(root);
+  }
+  catch (error) {
+    if (error?.code !== 'ENOENT') throw error;
+    root = requestedRoot;
+  }
   const envDb = global.root ? null : process.env.HCC_DB;
   const dbPath = path.resolve(global.db || envDb || projectDbPath(root));
-  return { cwd, root, dbPath, json: global.json, explicitRoot: Boolean(global.root || process.env.HCC_ROOT) };
+  return { cwd, root, dbPath, json: global.json,
+    explicitRoot: Boolean(global.root || process.env.HCC_ROOT), initialRootIdentity };
 }
 
 export function shellCommand(args, quoteArg) {

package/lib/core/coordination/results.mjs

@@ -1,5 +1,6 @@
 import { randomUUID } from 'node:crypto';
 import { tx } from '../../db/schema.mjs';
+import { automaticResultKey } from '../../shared/automatic-result-key.mjs';
 import { CliError } from '../../shared/errors.mjs';
 
 export const RESULT_EVENT = 'task.result.recorded';
@@ -18,7 +19,7 @@ function text(value, field, max, required = false) {
 
 // Evidence records do not mutate task status. The owner is checked in the same
 // transaction as the insert, including after a concurrent task takeover.
-export function recordTaskResult(db, input, { now = () => Math.floor(Date.now() / 1000), addEvent } = {}) {
+export function recordTaskResult(db, input, { now = () => Math.floor(Date.now() / 1000), addEvent, automatic = false } = {}) {
   if (!input || typeof input !== 'object' || Array.isArray(input)) throw new CliError('BAD_REQUEST', 'A result object is required');
   const peer = text(input.peer, 'peer', 200, true);
   const taskId = input.taskId;
@@ -29,21 +30,35 @@ export function recordTaskResult(db, input, { now = () => Math.floor(Date.now()
     throw new CliError('BAD_REQUEST', 'Unsupported result stage, status, kind or source');
   }
   if (source === 'executor' && stage !== 'local') throw new CliError('BAD_REQUEST', 'Executor records can only report local evidence');
+  if (automatic && (source !== 'executor' || !['command', 'diff'].includes(kind))) {
+    throw new CliError('BAD_REQUEST', 'Automatic results must be local executor commands or diffs');
+  }
   const evidence = input.evidence || [];
   if (!Array.isArray(evidence) || evidence.length > 20) throw new CliError('BAD_REQUEST', 'evidence must contain up to 20 text references');
   const references = evidence.map((entry) => text(entry, 'evidence', 2000, true));
   if (source === 'user' && status === 'passed' && !references.length) {
     throw new CliError('BAD_REQUEST', 'A passed verification needs an evidence reference');
   }
+  const executorId = text(input.executorId, 'executorId', 512) || null;
+  const threadId = text(input.threadId, 'threadId', 512) || null;
+  const turnId = text(input.turnId, 'turnId', 512) || null;
+  const itemId = text(input.itemId, 'itemId', 512) || null;
+  if (automatic && (!executorId || !threadId || !turnId || (kind === 'command' && !itemId))) {
+    throw new CliError('BAD_REQUEST', 'Automatic results require executor, thread, turn and command item identities');
+  }
+  const resultKey = automatic
+    ? automaticResultKey({ executorId, threadId, turnId, kind, itemId: kind === 'command' ? itemId : null })
+    : input.resultKey;
   const record = {
-    result_id: randomUUID(), result_key: text(input.resultKey, 'resultKey', 700) || randomUUID(),
+    result_id: randomUUID(), result_key: text(resultKey, 'resultKey', 700) || randomUUID(),
     peer, task_id: taskId, stage, status, kind, source,
-    title: text(input.title, 'title', 300, true), details: text(input.details, 'details', 64000), evidence: references,
-    command: text(input.command, 'command', 64000), diff: text(input.diff, 'diff', 64000),
-    executor_id: text(input.executorId, 'executorId', 512) || null,
-    thread_id: text(input.threadId, 'threadId', 512) || null,
-    turn_id: text(input.turnId, 'turnId', 512) || null,
-    item_id: text(input.itemId, 'itemId', 512) || null,
+    title: automatic ? (kind === 'command' ? 'Command execution' : 'Turn changes awaiting review')
+      : text(input.title, 'title', 300, true),
+    details: automatic ? '' : text(input.details, 'details', 64000),
+    evidence: automatic ? [] : references,
+    command: automatic ? '' : text(input.command, 'command', 64000),
+    diff: automatic ? '' : text(input.diff, 'diff', 64000),
+    executor_id: executorId, thread_id: threadId, turn_id: turnId, item_id: itemId,
     exit_code: Number.isSafeInteger(input.exitCode) ? input.exitCode : null,
     created_at: now()
   };
@@ -55,8 +70,10 @@ export function recordTaskResult(db, input, { now = () => Math.floor(Date.now()
       AND task_id = ? AND actor = ? AND json_valid(payload) AND json_extract(payload, '$.result_key') = ?
       ORDER BY id DESC LIMIT 1`).get(RESULT_EVENT, taskId, peer, record.result_key);
     if (previous) return { ...JSON.parse(previous.payload), id: previous.id, created_at: previous.created_at };
-    record.task_title = task.title;
-    record.task_status = task.status;
+    if (!automatic) {
+      record.task_title = task.title;
+      record.task_status = task.status;
+    }
     if (addEvent) addEvent(db, RESULT_EVENT, peer, taskId, record);
     else db.prepare('INSERT INTO events(type,actor,task_id,payload,created_at) VALUES(?,?,?,?,?)')
       .run(RESULT_EVENT, peer, taskId, JSON.stringify(record), record.created_at);

package/lib/core/sessions/hook-root-identity.mjs

@@ -0,0 +1,47 @@
+import path from 'node:path';
+import {
+  assertSelectedCwdSnapshot,
+  captureSelectedCwdSnapshot,
+  sameSelectedCwdIdentity
+} from '../../process/selected-cwd-identity.mjs';
+import { CliError } from '../../shared/errors.mjs';
+
+export const HOOK_ROOT_IDENTITY_ENV = 'HCC_HOOK_ROOT_IDENTITY';
+
+function mismatch() {
+  return new CliError('HOOK_ROOT_IDENTITY_MISMATCH',
+    'Hook project root no longer matches the provider launch identity');
+}
+
+// Carry the launch-time directory identity into short-lived hook children.
+// A pathname alone cannot distinguish a moved project from another directory
+// subsequently installed at the same pathname.
+export function hookRootIdentityValue(root, original = null) {
+  const selected = captureSelectedCwdSnapshot(root);
+  if (original) {
+    if (typeof original.assertUnchanged === 'function') original.assertUnchanged();
+    else assertSelectedCwdSnapshot(original);
+    if (!sameSelectedCwdIdentity(selected, original)) throw mismatch();
+  }
+  return JSON.stringify({ version: 1, ...selected });
+}
+
+export function assertHookRootIdentity(root, value) {
+  if (value === undefined) return false; // Unmanaged and pre-upgrade hooks have no launch marker.
+  try {
+    if (typeof value !== 'string' || value.length > 4096) throw mismatch();
+    const snapshot = JSON.parse(value);
+    if (!snapshot || typeof snapshot !== 'object' || Array.isArray(snapshot) ||
+        snapshot.version !== 1 || snapshot.requested !== path.resolve(root) ||
+        typeof snapshot.canonical !== 'string' || !path.isAbsolute(snapshot.canonical) ||
+        !snapshot.identity || typeof snapshot.identity !== 'object' ||
+        !/^\d+$/.test(snapshot.identity.dev) || !/^\d+$/.test(snapshot.identity.ino) ||
+        (snapshot.identity.birthtimeNs !== null && !/^\d+$/.test(snapshot.identity.birthtimeNs))) {
+      throw mismatch();
+    }
+    assertSelectedCwdSnapshot(snapshot);
+    return snapshot;
+  } catch {
+    throw mismatch();
+  }
+}