@logicseek/hello-cc 1.1.0-rc.8 → 1.1.0

package/lib/cli/commands/hook.mjs

@@ -6,6 +6,9 @@ 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';
+import { CODEX_SESSION_ORIGIN_ENV, recordCodexThreadRoot } from '../../core/sessions/codex-thread-root.mjs';
+import { captureSelectedCwdSnapshot, sameSelectedCwdIdentity } from '../../process/selected-cwd-identity.mjs';
+import { acquireNativeOwnerWrite, nativeOwnerGeneration } from '../../runtime/native/store.mjs';
 
 export function createHookCommand(deps) {
   const {
@@ -105,6 +108,17 @@ async function cmdHook(ctx, args) {
     }
   }
 
+  const codexOrigin = kind === 'codex' && hookKey === 'sessionstart' && !nativeOwner
+    ? process.env[CODEX_SESSION_ORIGIN_ENV] : null;
+  if (codexOrigin) {
+    if (!['new', 'fork'].includes(codexOrigin) || !launchRootIdentity ||
+        !process.env.HCC_PEER || !process.env.HCC_DB ||
+        !sameSelectedCwdIdentity(captureSelectedCwdSnapshot(hookCwd), launchRootIdentity)) {
+      throw new CliError('CODEX_HISTORY_BINDING_INVALID',
+        'First-party Codex session hook does not match its pinned project launch');
+    }
+  }
+
   const dshProject = isDsh && !nativeOwner ? resolveProjectDatabase({ root: hccRoot, createStateDir: false }) : null;
   const nativeProject = nativeOwner ? resolveProjectDatabase({ root: hccRoot,
     db: process.env.HCC_DB, createStateDir: false }) : null;
@@ -143,9 +157,17 @@ async function cmdHook(ctx, args) {
       : `${kind}-${shortHash(`${hookCtx.root}:${autoPeerBasis(kind)}`)}`;
   }
 
-  // Hook delivery must not migrate another workspace's registered database.
-  const db = isDsh || nativeOwner ? connect(hookCtx, { migrateRegistered: false }) : connect(hookCtx);
+  // Native hooks lock state.db before connect(), whose schema setup may write
+  // mesh.db. Keep that lock through the heartbeat transaction and DB close.
+  const nativeGeneration = nativeOwner ? nativeOwnerGeneration(nativeOwner) : null;
+  if (nativeOwner && !nativeGeneration) {
+    throw new CliError('NATIVE_HOOK_OWNERSHIP_MISMATCH', 'Native hook has no verifiable owner generation');
+  }
+  const finishNative = nativeOwner ? acquireNativeOwnerWrite(hookCtx, nativeGeneration) : null;
+  let db, nativeSuccess = false;
   try {
+    // Hook delivery must not migrate another workspace's registered database.
+    db = isDsh || nativeOwner ? connect(hookCtx, { migrateRegistered: false }) : connect(hookCtx);
     if (!nativeOwner) registerProjectActivity(hookCtx);
     if (nativeOwner) {
       // Native delivery owns context injection and completion receipts. Hooks
@@ -166,6 +188,7 @@ async function cmdHook(ctx, args) {
           ttlCap: 3600, includeExpired: true });
         if (renewed > 0) addEvent(db, 'lock.renewed_by_hook', peerId, null, { renewed, source: 'native-hook' });
       });
+      nativeSuccess = true;
       process.exitCode = 0;
       return;
     }
@@ -226,6 +249,9 @@ async function cmdHook(ctx, args) {
         runtime_session_id: peerId
       };
       const canonical = upsertCanonicalPeerBinding(db, hookBinding, true);
+      if (codexOrigin) {
+        recordCodexThreadRoot(db, addEvent, sessionId, launchRootIdentity, codexOrigin, { allowSame: true });
+      }
       if (canonical.peer !== peerId) {
         const previousPeer = peerId;
         peerId = canonical.peer;
@@ -254,7 +280,7 @@ async function cmdHook(ctx, args) {
     };
     // Keep the dsh conflict check and identity/binding writes atomic, so a
     // concurrent service/session registration cannot change the inspected row.
-    const registered = isDsh || kind === 'claude' ? tx(db, registerHookIdentity) : registerHookIdentity();
+    const registered = isDsh || kind === 'claude' || codexOrigin ? tx(db, registerHookIdentity) : registerHookIdentity();
     if (registered === false) { process.exitCode = 0; return; }
     // hb-06: an active hook is proof the peer is working. During clock grace,
     // renew retained locks even when the wall-clock jump made them look expired.
@@ -321,7 +347,8 @@ async function cmdHook(ctx, args) {
       }
     }
   } finally {
-    try { db.close(); } catch {}
+    try { db?.close(); } catch {}
+    finishNative?.(nativeSuccess);
   }
   // Let Node exit after the hook output has flushed instead of truncating a
   // pipe with process.exit(). A successful write is not provider acceptance.

package/lib/cli/commands/mcp.mjs

@@ -3,6 +3,7 @@ import { parseOpts, required, validateOpts, wantsHelp } from '../../cli-args.mjs
 import { loadScopedMcpBootstrap } from '../../mcp/scope.mjs';
 import { createScopedMcpTools } from '../../mcp/tools.mjs';
 import { serveMcpStdio } from '../../mcp/stdio.mjs';
+import { nativeOwnerGeneration } from '../../runtime/native/store.mjs';
 
 export function mcpHelp() {
   console.log(`Usage: hcc --root PROJECT --db DATABASE mcp serve --peer PEER
@@ -21,6 +22,11 @@ export function createMcpCommands(dependencies) {
     validateOpts('mcp serve', options, ['peer']);
     const peer = required(options, 'peer');
     const authority = loadScopedMcpBootstrap(ctx, peer);
+    const inheritedGeneration = process.env.HCC_NATIVE_OWNER && nativeOwnerGeneration(process.env.HCC_NATIVE_OWNER);
+    if (process.env.HCC_NATIVE_OWNER &&
+        (!inheritedGeneration || authority.scope.nativeOwnerGeneration !== inheritedGeneration)) {
+      throw new CliError('NATIVE_OWNER_UNVERIFIED', 'Native MCP capability does not match the inherited worker generation');
+    }
     const tools = createScopedMcpTools({ ...dependencies, ctx, authority });
     await serveMcpStdio({ tools });
   }

package/lib/cli/commands/native.mjs

@@ -5,6 +5,9 @@ import { parseOpts, validateOpts, wantsHelp, intOpt } from '../../cli-args.mjs';
 import { printResult } from '../../format.mjs';
 import { ensureNativeRuntime } from '../../runtime/native/launcher.mjs';
 import { nativeRequest } from '../../runtime/native/client.mjs';
+import { listCliSubmissions, matchingCliSubmission, prepareCliSubmission,
+  recordCliSubmissionReceipt } from '../../runtime/native/cli-submissions.mjs';
+import { assertPinnedSessionLaunchAllowed } from '../../process/pinned-cwd.mjs';
 import { startNativeService } from '../../runtime/native/service.mjs';
 
 export function nativeHelp() {
@@ -14,6 +17,7 @@ export function nativeHelp() {
        hcc native send --peer NAME --body TEXT [--from NAME] [--task ID] [--submission-id ID]
        hcc native events --peer NAME [--after ID]
        hcc native deliveries [--peer NAME]
+       hcc native submissions [--peer NAME]
        hcc native requests --peer NAME
        hcc native respond --peer NAME --request ID --decision accept|decline|cancel [--response-file JSON]
        hcc native interrupt --peer NAME [--turn ID]
@@ -21,8 +25,9 @@ export function nativeHelp() {
 
 Native workers share the project task/message/lock bus. Only HCC-owned saved
 sessions can resume. Existing TUI/Desktop sessions keep their own transport.
-Use a unique --submission-id for each new message and reuse it only for an
-exact retry after an uncertain receipt.
+Generated CLI submission IDs are saved before sending. Inspect native
+submissions after an uncertain receipt; retry only with the original ID and
+exact peer, sender, task and body. Explicit --submission-id also remains valid.
 Providers retain their permission checks; interactive requests await an explicit Web or local response.
 Codex alone accepts --sandbox. New sessions default to workspace-write; resumed and forked sessions inherit their saved policy.
 read-only disables permission escalation and HCC scoped MCP tools. It is a provider file sandbox, not an all-tools/network guarantee.
@@ -49,7 +54,7 @@ export function createNativeCommands(deps) {
       up: [], serve: [], down: [], status: [],
       start: ['peer', 'provider', 'cwd', 'model', 'binary', 'resume', 'sandbox'],
       send: ['peer', 'body', 'from', 'task', 'submission-id'],
-      events: ['peer', 'after'], deliveries: ['peer'], requests: ['peer'],
+      events: ['peer', 'after'], deliveries: ['peer'], submissions: ['peer'], requests: ['peer'],
       respond: ['peer', 'request', 'decision', 'response-file'],
       fork: ['peer', 'parent', 'model', 'binary'],
       interrupt: ['peer', 'turn'], close: ['peer']
@@ -73,6 +78,7 @@ export function createNativeCommands(deps) {
       process.once('SIGINT', shutdown);
       return;
     } else if (command === 'start') {
+      assertPinnedSessionLaunchAllowed();
       const runtime = await ensureNativeRuntime(ctx);
       if (opts.provider === 'codex') requireSandboxRuntime(runtime);
       result = await nativeRequest(ctx, 'POST', '/workers', { peer: opts.peer, provider: opts.provider,
@@ -80,6 +86,7 @@ export function createNativeCommands(deps) {
         ...(opts.sandbox !== undefined ? { sandbox: opts.sandbox } : {}) },
         opts.provider === 'codex' ? { expectedGeneration: runtime.generation } : undefined);
     } else if (command === 'fork') {
+      assertPinnedSessionLaunchAllowed();
       if (!opts.parent) throw new CliError('BAD_ARGS', 'Missing --parent');
       const runtime = await nativeRequest(ctx, 'GET', '/status');
       requireSandboxRuntime(runtime);
@@ -93,14 +100,20 @@ export function createNativeCommands(deps) {
         throw new CliError('BAD_ARGS', 'Submission ID must contain 8 to 100 letters, digits, underscores, or hyphens');
       }
       const sender = deps.resolveCurrentPeer(ctx, opts, 'from', 'shell').id;
+      const input = { peer: opts.peer, from: sender, taskId, body: opts.body };
+      const prepared = submissionId ? matchingCliSubmission(ctx, { ...input, submissionId })
+        : prepareCliSubmission(ctx, input);
       result = await nativeRequest(ctx, 'POST', '/send', { peer: opts.peer, from: sender, body: opts.body, taskId,
-        ...(submissionId ? { submissionId } : {}) });
+        submissionId: submissionId || prepared.submission_id });
+      if (prepared) recordCliSubmissionReceipt(ctx, prepared, result);
     } else if (command === 'events') {
       const after = intOpt(opts, 'after', 0);
       if (after < 0) throw new CliError('BAD_ARGS', 'Event cursor must be nonnegative');
       result = await nativeRequest(ctx, 'GET', `/events?peer=${encodeURIComponent(opts.peer)}&after=${after}`);
     } else if (command === 'deliveries') {
       result = await nativeRequest(ctx, 'GET', `/deliveries${opts.peer ? `?peer=${encodeURIComponent(opts.peer)}` : ''}`);
+    } else if (command === 'submissions') {
+      result = listCliSubmissions(ctx, { peer: opts.peer || null });
     } else if (command === 'requests' || command === 'respond') {
       const state = await nativeRequest(ctx, 'GET', '/workers/' + encodeURIComponent(opts.peer) + '/state');
       if (command === 'requests') result = state.snapshot.pendingApprovals || [];

package/lib/cli/commands/peer.mjs

@@ -5,6 +5,7 @@ import {
   RUNTIME_SESSION_START_TIMEOUT_MS
 } from '../../runtime/client.mjs';
 import { captureSelectedCwdSnapshot } from '../../process/selected-cwd-identity.mjs';
+import { assertCodexTerminalLaunch } from '../../core/sessions/codex-thread-root.mjs';
 
 export function createPeerCommands(deps) {
   const {
@@ -96,6 +97,8 @@ async function peerStart(ctx, args) {
   const db = connect(ctx);
   try {
     tx(db, () => {
+      assertCodexTerminalLaunch(db, binding, { command, root: ctx.root,
+        rootIdentity: ctx.initialRootIdentity, cwd, cwdIdentity });
       if (!opts.force) {
         const conflict = findProviderSessionBinding(db, binding);
         if (bindingHasRuntime(conflict)) {

package/lib/cli/commands/run.mjs

@@ -6,9 +6,10 @@ 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 { assertPinnedSessionLaunchAllowed, preparePinnedCwdLaunch } from '../../process/pinned-cwd.mjs';
+import { assertSelectedCwdSnapshot, 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';
@@ -31,6 +32,7 @@ import {
 } from '../../process/pty-lifecycle.mjs';
 import { detectBranch } from '../../project-context.mjs';
 import { childSessionEnv } from '../../core/sessions/launch.mjs';
+import { assertCodexTerminalLaunch, CODEX_SESSION_ORIGIN_ENV } from '../../core/sessions/codex-thread-root.mjs';
 import {
   bindingFromRun,
   defaultSessionCommand
@@ -42,12 +44,22 @@ export function createRunCommands(deps) {
   const {
     connect, now, addEvent, auditPayload,
     upsertPeer, upsertCanonicalPeerBinding,
-    helpRun, redactedLogText, CLI_NAME, BUFS_DIR_NAME
+    helpRun, redactedLogText, CLI_NAME, BUFS_DIR_NAME,
+    spawnProcess = spawn,
+    loadPty = () => import('node-pty')
   } = deps;
 
+  const assertRunDirectories = (ctx, cwdIdentity = null) => {
+    if (ctx.initialRootIdentity) assertSelectedCwdSnapshot(ctx.initialRootIdentity);
+    if (cwdIdentity && cwdIdentity !== ctx.initialRootIdentity) assertSelectedCwdSnapshot(cwdIdentity);
+  };
+
 async function cmdRun(ctx, args) {
   if (args[0] === '--help' || args[0] === '-h') return helpRun();
-  registerProjectActivity(ctx);
+  // A rollout hold must not publish a running peer before the launch is
+  // refused. Existing sessions remain untouched.
+  assertPinnedSessionLaunchAllowed();
+  assertRunDirectories(ctx);
   const sep = args.indexOf('--');
   const optArgs = sep >= 0 ? args.slice(0, sep) : args;
   const cmdArgs = sep >= 0 ? args.slice(sep + 1) : [];
@@ -58,10 +70,22 @@ 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 expectedCwdIdentity = ctx.initialRootIdentity && cwd === path.resolve(ctx.root)
+    ? ctx.initialRootIdentity : captureSelectedCwdSnapshot(cwd);
+  assertRunDirectories(ctx, expectedCwdIdentity);
   const command = cmdArgs.length ? cmdArgs[0] : defaultSessionCommand(kind);
   const commandArgs = cmdArgs.length ? cmdArgs.slice(1) : [];
   const binding = bindingFromRun(id, kind, command, commandArgs, 'hcc-run');
+  const originBinding = kind === 'codex' && binding.resume_mode === 'command' &&
+    path.basename(command) === 'codex' && commandArgs.length === 0
+    ? { ...binding, resume_mode: 'new' } : binding;
+  const validationDb = connect(ctx);
+  let codexOrigin;
+  try {
+    codexOrigin = assertCodexTerminalLaunch(validationDb, originBinding, {
+      command: binding.command, argv: [command, ...commandArgs], root: ctx.root,
+      rootIdentity: ctx.initialRootIdentity, cwd, cwdIdentity: expectedCwdIdentity });
+  } finally { validationDb.close(); }
 
   if (process.env.HCC_INTERNAL_WEB_MANAGED_RUN === '1') {
     return cmdRunWebManaged(ctx, {
@@ -73,10 +97,20 @@ async function cmdRun(ctx, args) {
       command,
       commandArgs,
       binding,
+      codexOrigin,
       force: Boolean(opts.force)
     });
   }
 
+  const launch = preparePinnedCwdLaunch(cwd, command, commandArgs, {
+    expectedIdentity: expectedCwdIdentity,
+    env: childSessionEnv({ HCC_PEER: id, HCC_ROOT: ctx.root, HCC_DB: ctx.dbPath,
+      ...(codexOrigin ? { [CODEX_SESSION_ORIGIN_ENV]: codexOrigin } : {}) },
+    process.env, { rootIdentity: ctx.initialRootIdentity })
+  });
+  try {
+    assertRunDirectories(ctx, expectedCwdIdentity);
+    registerProjectActivity(ctx);
   const db = connect(ctx);
   const wrapperIdentity = runtimeProcessIdentity();
   try {
@@ -95,6 +129,7 @@ async function cmdRun(ctx, args) {
         }]
       }) : null;
       registered = tx(db, () => {
+        assertRunDirectories(ctx, expectedCwdIdentity);
         const current = db.prepare('SELECT * FROM peers WHERE id = ?').get(id) || null;
         if (JSON.stringify(current) !== JSON.stringify(previous)) return false;
         if (previous && evidence.state !== 'dead' && (
@@ -134,20 +169,32 @@ async function cmdRun(ctx, args) {
     db.close();
   }
   console.error(redactedLogText(`${CLI_NAME}: running ${id} (${kind}, ${role}) -> ${command} ${commandArgs.join(' ')}`.trim()));
-  const child = spawnPinnedCwdProcess(command, commandArgs, {
-    cwd,
-    expectedIdentity: expectedCwdIdentity,
-    stdio: 'inherit',
-    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 }));
-    child.on('error', (err) => {
-      console.error(redactedLogText(`${CLI_NAME}: failed to start ${command}: ${err.message}`));
-      resolve({ code: 127, signal: null });
+  let exitCode;
+  let child;
+  try {
+    child = spawnProcess(launch.command, launch.args, {
+      cwd: launch.cwd, env: launch.env, stdio: 'inherit'
     });
-  });
+  } catch (err) {
+    // A synchronous spawn rejection did not create a child. Retain the audit
+    // trail, but close this wrapper's owned peer below instead of leaving it
+    // falsely running. Never roll back a possibly superseded binding/event.
+    exitCode = { code: 127, signal: null, startup: true,
+      error: err?.code || err?.message || 'spawn_failed' };
+    console.error(redactedLogText(`${CLI_NAME}: failed to start ${command}: ${err.message}`));
+  }
+  if (child) {
+    child.once('exit', launch.release);
+    child.once('error', launch.release);
+    exitCode = await new Promise((resolve) => {
+      child.on('exit', (code, signal) => resolve({ code, signal }));
+      child.on('error', (err) => {
+        console.error(redactedLogText(`${CLI_NAME}: failed to start ${command}: ${err.message}`));
+        resolve({ code: 127, signal: null, startup: true,
+          error: err?.code || err?.message || 'spawn_failed' });
+      });
+    });
+  }
   const db2 = connect(ctx);
   try {
     tx(db2, () => {
@@ -172,6 +219,9 @@ async function cmdRun(ctx, args) {
   } else {
     process.exitCode = exitCode.code ?? 0;
   }
+  } finally {
+    launch.release();
+  }
 }
 
 /**
@@ -179,11 +229,26 @@ 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, expectedCwdIdentity, command, commandArgs, binding, force = false }) {
-  registerProjectActivity(ctx);
-  const ptyModule = await import('node-pty');
+async function cmdRunWebManaged(ctx, { id, kind, role, cwd, expectedCwdIdentity, command, commandArgs, binding,
+  codexOrigin = null, force = false }) {
+  assertPinnedSessionLaunchAllowed();
+  const cwdIdentity = expectedCwdIdentity || (ctx.initialRootIdentity && cwd === path.resolve(ctx.root)
+    ? ctx.initialRootIdentity : captureSelectedCwdSnapshot(cwd));
+  assertRunDirectories(ctx, cwdIdentity);
+  const ptyModule = await loadPty();
   const pty = ptyModule.default || ptyModule;
 
+  const launch = preparePinnedCwdLaunch(cwd, command, commandArgs, {
+    expectedIdentity: cwdIdentity,
+    env: childSessionEnv({ HCC_PEER: id, HCC_ROOT: ctx.root, HCC_DB: ctx.dbPath, TERM: 'xterm-256color',
+      ...(codexOrigin ? { [CODEX_SESSION_ORIGIN_ENV]: codexOrigin } : {}) },
+    process.env, { rootIdentity: ctx.initialRootIdentity })
+  });
+  try {
+    assertRunDirectories(ctx, cwdIdentity);
+    registerProjectActivity(ctx);
+
+  assertRunDirectories(ctx, cwdIdentity);
   const bufsDir = ensurePrivateProjectBufferDirectory(ctx.root, BUFS_DIR_NAME);
   const outFile = path.join(bufsDir, `${id}.out`);
   const inFile  = path.join(bufsDir, `${id}.in`);
@@ -208,11 +273,22 @@ async function cmdRunWebManaged(ctx, { id, kind, role, cwd, expectedCwdIdentity,
     }
     return true;
   });
+  const createdBufferFiles = [];
+  const removeCreatedBufferFiles = () => {
+    for (const { file, dev, ino, birthtimeNs } of createdBufferFiles) {
+      try {
+        const stat = fs.lstatSync(file, { bigint: true });
+        if (stat.isFile() && stat.dev === dev && stat.ino === ino &&
+            stat.birthtimeNs === birthtimeNs) fs.unlinkSync(file);
+      } catch {}
+    }
+  };
 
   // Publish live wrapper evidence in the same lease that creates the group.
   // This closes the pre-.meta window even for `gc --older-than 0`.
   const publishingWrapperIdentity = runtimeProcessIdentity();
   withBufferDirectoryLease(bufsDir, () => {
+    assertRunDirectories(ctx, cwdIdentity);
     const existingFiles = bufferFiles.filter((file) => fs.existsSync(file));
     if (existingFiles.length > 0) {
       let existingMeta;
@@ -224,45 +300,76 @@ async function cmdRunWebManaged(ctx, { id, kind, role, cwd, expectedCwdIdentity,
       }
       for (const file of bufferFiles) fs.rmSync(file, { force: true });
     }
-    fs.writeFileSync(inFile, '', { flag: 'wx', mode: 0o600 });
-    fs.writeFileSync(resizeFile, '', { flag: 'wx', mode: 0o600 });
-    fs.writeFileSync(metaFile, JSON.stringify({
-      id,
-      generation: bufferGeneration,
-      kind,
-      role,
-      command: [command, ...commandArgs].join(' '),
-      cwd,
-      wrapper_pid: process.pid,
-      ...(publishingWrapperIdentity ? { wrapper_identity: publishingWrapperIdentity } : {}),
-      publishing: true
-    }), { flag: 'wx', mode: 0o600 });
-
-    const db = connect(ctx);
+    const createOwnedFile = (file, contents) => {
+      const fd = fs.openSync(file, fs.constants.O_WRONLY | fs.constants.O_CREAT |
+        fs.constants.O_EXCL | (fs.constants.O_NOFOLLOW || 0), 0o600);
+      try {
+        const stat = fs.fstatSync(fd, { bigint: true });
+        createdBufferFiles.push({ file, dev: stat.dev, ino: stat.ino,
+          birthtimeNs: stat.birthtimeNs });
+        fs.writeFileSync(fd, contents);
+      } finally { fs.closeSync(fd); }
+    };
     try {
-      tx(db, () => {
-        upsertPeer(db, {
-          id, kind, role,
-          worktree: cwd,
-          branch: detectBranch(cwd),
-          pid: process.pid,
-          status: 'running',
-          capabilities: 'run-pty'
+      createOwnedFile(inFile, '');
+      createOwnedFile(resizeFile, '');
+      createOwnedFile(metaFile, JSON.stringify({
+        id,
+        generation: bufferGeneration,
+        kind,
+        role,
+        command: [command, ...commandArgs].join(' '),
+        cwd,
+        wrapper_pid: process.pid,
+        ...(publishingWrapperIdentity ? { wrapper_identity: publishingWrapperIdentity } : {}),
+        publishing: true
+      }));
+
+      const db = connect(ctx);
+      try {
+        tx(db, () => {
+          assertRunDirectories(ctx, cwdIdentity);
+          const previous = db.prepare('SELECT * FROM peers WHERE id = ?').get(id) || null;
+          const evidence = previous ? resolvePeerEvidence({
+            peer: previous,
+            processes: [{
+              storedIdentity: {
+                pid: Number(previous.pid),
+                startToken: previous.pid_start_token,
+                commandHash: previous.pid_command_hash
+              },
+              current: inspectProcessIdentity(previous.pid)
+            }]
+          }) : null;
+          if (previous && evidence.state !== 'dead' && (
+            previous.pid || ['running', 'working', 'busy', 'starting', 'blocked', 'detached'].includes(previous.status)
+          )) {
+            throw new CliError('PEER_SESSION_EXISTS', `Peer ${id} already has a live or unresolved owner`, {
+              peer: id, evidence_state: evidence.state
+            });
+          }
+          upsertPeer(db, {
+            id, kind, role,
+            worktree: cwd,
+            branch: detectBranch(cwd),
+            pid: process.pid,
+            processIdentity: publishingWrapperIdentity,
+            status: 'running',
+            capabilities: 'run-pty'
+          });
+          upsertCanonicalPeerBinding(db, binding, force);
+          addEvent(db, 'run.session.started', id, null, auditPayload({
+            actor: id,
+            target: id,
+            command: [command, ...commandArgs].join(' '),
+            cwd,
+            webManaged: true
+          }));
         });
-        upsertCanonicalPeerBinding(db, binding, force);
-        addEvent(db, 'run.session.started', id, null, auditPayload({
-          actor: id,
-          target: id,
-          command: [command, ...commandArgs].join(' '),
-          cwd,
-          webManaged: true
-        }));
-      });
+      } finally { db.close(); }
     } catch (error) {
-      for (const file of bufferFiles) fs.rmSync(file, { force: true });
+      removeCreatedBufferFiles();
       throw error;
-    } finally {
-      db.close();
     }
   });
 
@@ -270,12 +377,36 @@ async function cmdRunWebManaged(ctx, { id, kind, role, cwd, expectedCwdIdentity,
   const cols = process.stdout.columns || 120;
   const rows = process.stdout.rows || 40;
 
-  const child = spawnPinnedCwdPty(pty, command, commandArgs, {
-    name: 'xterm-256color', cols, rows, cwd,
-    expectedIdentity: expectedCwdIdentity,
-    env: childSessionEnv({ HCC_PEER: id, HCC_ROOT: ctx.root, HCC_DB: ctx.dbPath, TERM: 'xterm-256color' },
-      process.env, { rootIdentity: ctx.initialRootIdentity })
-  });
+  let child;
+  try {
+    child = pty.spawn(launch.command, launch.args, {
+      name: 'xterm-256color', cols, rows, cwd: launch.cwd, env: launch.env
+    });
+  } catch (error) {
+    // No PTY was returned. Only the current buffer generation may be removed;
+    // historical bindings/events are kept as audit evidence rather than
+    // blindly restored over a possible replacement owner.
+    try { withBufferDirectoryLease(bufsDir, removeCreatedBufferFiles); } catch {}
+    const failedDb = connect(ctx);
+    try {
+      tx(failedDb, () => {
+        const mutation = failedDb.prepare(`
+          UPDATE peers SET status = ?, last_seen_at = ?
+          WHERE id = ? AND pid IS ? AND pid_start_token IS ? AND pid_command_hash IS ?
+            AND status = 'running' AND capabilities = 'run-pty'
+        `).run('exited', now(), id, process.pid, publishingWrapperIdentity?.startToken || null,
+          publishingWrapperIdentity?.commandHash || null);
+        if (Number(mutation.changes) > 0) {
+          addEvent(failedDb, 'run.session.exited', id, null, auditPayload({
+            actor: id, target: id, code: 127, signal: null, startup: true,
+            error: error?.code || error?.message || 'pty_spawn_failed'
+          }));
+        }
+      });
+    } finally { failedDb.close(); }
+    throw error;
+  }
+  child.onExit(launch.release);
   const childExit = trackPtyExit(child);
   const wrapperTermination = installPtyTerminationHandlers(child);
   let outFd;
@@ -510,6 +641,9 @@ async function cmdRunWebManaged(ctx, { id, kind, role, cwd, expectedCwdIdentity,
   } else {
     process.exitCode = exitCode.exitCode ?? 0;
   }
+  } finally {
+    launch.release();
+  }
 }
 
   return { cmdRun, cmdRunWebManaged };

package/lib/cli/commands/tmux.mjs

@@ -35,7 +35,7 @@ export function createTmuxCommands(deps) {
   const {
     connect, now, addEvent, auditPayload,
     upsertPeer, upsertCanonicalPeerBinding,
-    loadDiscover, sameResolvedPath,
+    loadDiscover,
     helpTmux,
     canonicalRoot, rootEvidence, processEvidenceFromRow,
     inspectTmuxTarget, isProjectManagedTmuxSession
@@ -43,39 +43,48 @@ export function createTmuxCommands(deps) {
 
 async function cmdScan(ctx, args) {
   const opts = parseOpts(args, { booleans: ['register'] });
-  const { scanClaudeSessions, scanCodexSessions, scanProcesses } = await loadDiscover();
-
-  const found = [
-    ...scanClaudeSessions(),
-    ...scanCodexSessions(),
-    ...scanProcesses(),
-  ].filter((s) => sameResolvedPath(s.hccRoot, ctx.root));
+  const { scanProcesses, verifiedLiveProcessForRoot, canRegisterProcessOnly } = await loadDiscover();
+  const found = scanProcesses().map((s) => verifiedLiveProcessForRoot(s, ctx)).filter(Boolean);
 
   // Deduplicate by peerId
   const byId = new Map();
   for (const s of found) {
     if (!byId.has(s.peerId)) byId.set(s.peerId, s);
   }
-  const results = [...byId.values()];
+  let results = [...byId.values()];
 
   if (opts.register && results.length) {
-    registerProjectActivity(ctx);
     const db = connect(ctx);
+    const registered = [];
     try {
       for (const s of results) {
-        upsertPeer(db, {
-          id: s.peerId, kind: s.kind, role: 'peer',
-          worktree: s.cwd,
-          branch: detectBranch(s.cwd),
-          pid: s.pid,
-          status: s.status || 'running',
-          capabilities: 'detected'
-        });
-        upsertCanonicalPeerBinding(db, bindingFromDetected(s, s.transport || 'detected'), true);
+        try {
+          const live = tx(db, () => {
+            const current = verifiedLiveProcessForRoot(s, ctx);
+            if (!current) return null;
+            if (!canRegisterProcessOnly(db, current)) return null;
+            upsertPeer(db, {
+              id: current.peerId, kind: current.kind, role: 'peer',
+              worktree: current.cwd, branch: detectBranch(current.cwd),
+              pid: current.pid, processIdentity: current.processIdentity,
+              status: current.status || 'running', capabilities: 'detected'
+            });
+            upsertCanonicalPeerBinding(db, bindingFromDetected(current, current.transport || 'detected'), true);
+            if (!verifiedLiveProcessForRoot(current, ctx)) {
+              throw Object.assign(new Error('Discovered process changed during registration'), { code: 'DISCOVERY_PROCESS_CHANGED' });
+            }
+            return current;
+          });
+          if (live) registered.push(live);
+        } catch (error) {
+          if (error?.code !== 'DISCOVERY_PROCESS_CHANGED') throw error;
+        }
       }
     } finally {
       db.close();
     }
+    if (registered.length) registerProjectActivity(ctx);
+    results = registered;
   }
 
   printResult(ctx, results, (rows) => {