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

package/lib/web/tls.mjs

@@ -5,12 +5,18 @@ import { spawnSync } from 'node:child_process';
 import { createPublicKey, randomBytes, X509Certificate } from 'node:crypto';
 import { isIP } from 'node:net';
 import { CliError } from '../shared/errors.mjs';
-import { globalStateDir } from '../runtime/paths.mjs';
+import { ensurePrivateGlobalSubdirectory } from '../runtime/private-state.mjs';
+import { readPrivateTextFile } from '../runtime/private-file.mjs';
+import { unsafeDirectoryAcl } from '../runtime/project-trust.mjs';
 
 const CERT_RENEW_BEFORE_MS = 7 * 24 * 60 * 60 * 1000;
 const GENERATION_CLEANUP_GRACE_MS = 60 * 60 * 1000;
 const GENERATION_NAME_RE = /^generation-[a-z0-9-]+$/i;
 const OWNED_GENERATION_NAME_RE = /^generation-[a-z0-9]+-(\d+)-[a-f0-9]+$/i;
+const TLS_KEY_MAX_BYTES = 16384;
+const TLS_CERT_MAX_BYTES = 65536;
+const TLS_POINTER_MAX_BYTES = 16384;
+const TLS_MARKER_MAX_BYTES = 128;
 
 // hello-cc can serve the web console over HTTPS with an auto-generated
 // self-signed certificate. This protects against passive LAN sniffing of the
@@ -93,10 +99,48 @@ export function tlsCredentialsAreReusable({ key, cert, sanEntries, nowMs = Date.
   }
 }
 
+// The tls/ parent is validated before this module runs, but a generation may
+// have been planted while an older installation still left that parent public.
+// Do not follow or repair a foreign, redirected, or cross-UID-writable child.
+function trustedTlsDirectory(directory, { tighten = false } = {}) {
+  let fd;
+  try {
+    const before = fs.lstatSync(directory, { bigint: true });
+    if (before.isSymbolicLink() || !before.isDirectory() ||
+        before.uid !== BigInt(process.getuid())) return null;
+    fd = fs.openSync(directory, fs.constants.O_RDONLY |
+      fs.constants.O_DIRECTORY | fs.constants.O_NOFOLLOW);
+    let opened = fs.fstatSync(fd, { bigint: true });
+    if (!opened.isDirectory() || opened.dev !== before.dev || opened.ino !== before.ino ||
+        opened.uid !== before.uid || (opened.mode & 0o022n) !== 0n ||
+        unsafeDirectoryAcl(directory, opened)) return null;
+    if (tighten && (opened.mode & 0o777n) !== 0o700n) {
+      fs.fchmodSync(fd, 0o700);
+      opened = fs.fstatSync(fd, { bigint: true });
+      if ((opened.mode & 0o777n) !== 0o700n) return null;
+    }
+    const after = fs.lstatSync(directory, { bigint: true });
+    if (after.isSymbolicLink() || after.dev !== opened.dev || after.ino !== opened.ino ||
+        after.uid !== opened.uid) return null;
+    return opened;
+  } catch {
+    return null;
+  } finally {
+    if (fd !== undefined) fs.closeSync(fd);
+  }
+}
+
+function readPrivateMarker(file) {
+  try { return readPrivateTextFile(file, { maxBytes: TLS_MARKER_MAX_BYTES }); }
+  catch { return null; }
+}
+
 function readReusableCredentials(keyPath, certPath, sanEntries) {
   try {
-    const key = fs.readFileSync(keyPath, 'utf8');
-    const cert = fs.readFileSync(certPath, 'utf8');
+    if (!trustedTlsDirectory(path.dirname(keyPath), { tighten: true })) return null;
+    const key = readPrivateTextFile(keyPath, { maxBytes: TLS_KEY_MAX_BYTES });
+    const cert = readPrivateTextFile(certPath, { maxBytes: TLS_CERT_MAX_BYTES });
+    if (key === null || cert === null) return null;
     if (!tlsCredentialsAreReusable({ key, cert, sanEntries })) return null;
     return { key, cert, certPath };
   } catch {
@@ -165,7 +209,11 @@ function generateCredentials(dir, keyPath, certPath, sanEntries) {
 
 function readCurrentGeneration(dir) {
   try {
-    const pointer = JSON.parse(fs.readFileSync(path.join(dir, 'current.json'), 'utf8'));
+    const text = readPrivateTextFile(path.join(dir, 'current.json'), {
+      maxBytes: TLS_POINTER_MAX_BYTES
+    });
+    if (text === null) return null;
+    const pointer = JSON.parse(text);
     const generation = String(pointer?.generation || '');
     return GENERATION_NAME_RE.test(generation) ? generation : null;
   } catch {
@@ -188,12 +236,12 @@ function generationCreationIsActive(generationDir, generation) {
   const nameMatch = generation.match(OWNED_GENERATION_NAME_RE);
   const namePid = nameMatch ? Number.parseInt(nameMatch[1], 10) : null;
   try {
-    const ownerPid = Number.parseInt(fs.readFileSync(creatingPath, 'utf8').trim(), 10);
+    const ownerPid = Number.parseInt(readPrivateMarker(creatingPath)?.trim(), 10);
     if (Number.isInteger(ownerPid) && ownerPid > 0 && (!namePid || ownerPid === namePid)) {
       return processIsAlive(ownerPid);
     }
   } catch {}
-  if (fs.existsSync(path.join(generationDir, '.published'))) return false;
+  if (readPrivateMarker(path.join(generationDir, '.published')) !== null) return false;
 
   // Backward compatibility for generations created before lifecycle markers
   // were added, including the mkdir-to-marker window in a concurrent creator.
@@ -214,19 +262,23 @@ function writeGenerationCreatingMarker(generationDir) {
 function markGenerationPublished(generationDir) {
   const creatingPath = path.join(generationDir, '.creating');
   const publishedPath = path.join(generationDir, '.published');
+  if (readPrivateMarker(creatingPath) !== null) {
+    try { fs.renameSync(creatingPath, publishedPath); return; } catch {}
+  }
+  if (readPrivateMarker(publishedPath) !== null) return;
+  let fd;
   try {
-    fs.renameSync(creatingPath, publishedPath);
+    fd = fs.openSync(publishedPath, fs.constants.O_WRONLY | fs.constants.O_CREAT |
+      fs.constants.O_EXCL | fs.constants.O_NOFOLLOW, 0o600);
+    fs.writeFileSync(fd, `${process.pid}\n`);
   } catch {
-    try { fs.writeFileSync(publishedPath, `${process.pid}\n`, { mode: 0o600 }); } catch {}
-    if (fs.existsSync(publishedPath)) {
-      try { fs.rmSync(creatingPath, { force: true }); } catch {}
-    }
+    // A bad preexisting marker must not block use of otherwise safe credentials.
+  } finally {
+    if (fd !== undefined) fs.closeSync(fd);
   }
-  try { fs.chmodSync(publishedPath, 0o600); } catch {}
 }
 
 function currentGenerationCredentials(dir, sanEntries) {
-  const pointerPath = path.join(dir, 'current.json');
   try {
     const generation = readCurrentGeneration(dir);
     if (!generation) return null;
@@ -235,10 +287,6 @@ function currentGenerationCredentials(dir, sanEntries) {
     const certPath = path.join(generationDir, 'self-signed.crt');
     const credentials = readReusableCredentials(keyPath, certPath, sanEntries);
     if (!credentials) return null;
-    try { fs.chmodSync(generationDir, 0o700); } catch {}
-    try { fs.chmodSync(keyPath, 0o600); } catch {}
-    try { fs.chmodSync(certPath, 0o600); } catch {}
-    try { fs.chmodSync(pointerPath, 0o600); } catch {}
     markGenerationPublished(generationDir);
     return credentials;
   } catch {
@@ -252,7 +300,6 @@ function publishGeneration(dir, generation) {
   try {
     fs.writeFileSync(tmpPointerPath, `${JSON.stringify({ generation })}\n`, { mode: 0o600 });
     fs.renameSync(tmpPointerPath, pointerPath);
-    try { fs.chmodSync(pointerPath, 0o600); } catch {}
   } finally {
     try { fs.rmSync(tmpPointerPath, { force: true }); } catch {}
   }
@@ -266,11 +313,8 @@ function pruneOldGenerations(dir, t = Date.now()) {
     const generations = fs.readdirSync(dir, { withFileTypes: true })
       .filter((entry) => entry.isDirectory() && GENERATION_NAME_RE.test(entry.name))
       .map((entry) => {
-        try {
-          return { name: entry.name, mtimeMs: fs.statSync(path.join(dir, entry.name)).mtimeMs };
-        } catch {
-          return null;
-        }
+        const stat = trustedTlsDirectory(path.join(dir, entry.name));
+        return stat ? { name: entry.name, mtimeMs: Number(stat.mtimeMs), dev: stat.dev, ino: stat.ino } : null;
       })
       .filter(Boolean)
       .sort((a, b) => b.mtimeMs - a.mtimeMs);
@@ -279,12 +323,17 @@ function pruneOldGenerations(dir, t = Date.now()) {
     for (const generation of generations) {
       if (generation.name === current) continue;
       const generationDir = path.join(dir, generation.name);
-      const hasCreatingMarker = fs.existsSync(path.join(generationDir, '.creating'));
+      const hasCreatingMarker = readPrivateMarker(path.join(generationDir, '.creating')) !== null;
       if (generationCreationIsActive(generationDir, generation.name)) continue;
       let complete = false;
       try {
-        complete = fs.statSync(path.join(generationDir, 'self-signed.key')).size > 0 &&
-          fs.statSync(path.join(generationDir, 'self-signed.crt')).size > 0;
+        const key = readPrivateTextFile(path.join(generationDir, 'self-signed.key'), {
+          maxBytes: TLS_KEY_MAX_BYTES
+        });
+        const cert = readPrivateTextFile(path.join(generationDir, 'self-signed.crt'), {
+          maxBytes: TLS_CERT_MAX_BYTES
+        });
+        complete = Boolean(key?.length && cert?.length);
       } catch {}
       if (!keptPrevious && complete && !hasCreatingMarker) {
         keptPrevious = true;
@@ -293,9 +342,15 @@ function pruneOldGenerations(dir, t = Date.now()) {
       // A concurrently generated directory may not be published yet. Leave
       // recent candidates alone; a later startup will collect stale losers.
       if (t - generation.mtimeMs < GENERATION_CLEANUP_GRACE_MS) continue;
-      // current.json can change while this best-effort scan is running.
-      if (readCurrentGeneration(dir) === generation.name) continue;
+      // current.json can change while this best-effort scan is running. An
+      // unreadable or concurrently replaced pointer is not proof that this
+      // generation is stale, so leave cleanup for a later startup.
+      const latestCurrent = readCurrentGeneration(dir);
+      if (!latestCurrent) return;
+      if (latestCurrent === generation.name) continue;
       if (generationCreationIsActive(generationDir, generation.name)) continue;
+      const beforeDelete = trustedTlsDirectory(generationDir);
+      if (!beforeDelete || beforeDelete.dev !== generation.dev || beforeDelete.ino !== generation.ino) continue;
       try { fs.rmSync(generationDir, { recursive: true, force: true }); } catch {}
     }
   } catch {
@@ -338,10 +393,8 @@ function createGeneration(dir, sanEntries, source = null) {
  * browser trust decision is stable.
  */
 export function ensureSelfSignedCert(extraHosts = []) {
-  const dir = path.join(globalStateDir(), 'tls');
+  const dir = ensurePrivateGlobalSubdirectory('tls');
   const sanEntries = lanIpSanEntries(Array.isArray(extraHosts) ? extraHosts : [extraHosts]);
-  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
-  try { fs.chmodSync(dir, 0o700); } catch {}
 
   const existing = currentGenerationCredentials(dir, sanEntries);
   if (existing) {
@@ -356,8 +409,6 @@ export function ensureSelfSignedCert(extraHosts = []) {
     sanEntries
   );
   if (legacy) {
-    try { fs.chmodSync(path.join(dir, 'self-signed.key'), 0o600); } catch {}
-    try { fs.chmodSync(path.join(dir, 'self-signed.crt'), 0o600); } catch {}
     return createGeneration(dir, sanEntries, legacy);
   }
 

package/lib/web/tmux-sessions.mjs

@@ -12,6 +12,8 @@ import { CliError } from '../shared/errors.mjs';
 import { tx } from '../db/schema.mjs';
 import { required } from '../cli-args.mjs';
 import { readClockGraceUntil } from '../shared/clock-grace.mjs';
+import { preparePinnedCwdLaunch } from '../process/pinned-cwd.mjs';
+import { captureSelectedCwdSnapshot } from '../process/selected-cwd-identity.mjs';
 import { peerEvidenceAllowsReap } from '../core/peers/evidence.mjs';
 import { isDshHookBinding } from '../core/peers/bindings.mjs';
 import { conditionalTmuxKill, conditionalTmuxRename, prepareTmuxRestartBinding, rollbackTmuxRestartBinding, validateTmuxDestructiveEvidence } from '../core/peers/tmux-safety.mjs';
@@ -22,9 +24,65 @@ import { detectBranch } from '../project-context.mjs';
 import { adoptionPaused } from './adoption-state.mjs';
 import { ensureTmuxAvailable, runTmux, tmuxCapturePane, tmuxEnvironmentArgs, tmuxHasSession, tmuxKillSession, tmuxLaunchFingerprint, tmuxListSessionNames, tmuxManagedSessionName, tmuxManagedSessionNameMatches, tmuxPaneInfo, tmuxProviderState, tmuxSendLiteral, tmuxSessionEnvironmentValue, tmuxSessionHasClients } from '../tmux.mjs';
 
+// tmux returns after creating a pane, not after its command has entered cwd.
+// Keep the parent's captured directory FD alive until the bootstrap confirms
+// the checked chdir, or tmux definitively reports that the pane exited.
+export function monitorPinnedTmuxLaunch(binding, paneTarget, { paneInfo = tmuxPaneInfo, intervalMs = 100 } = {}) {
+  let timer;
+  let released = false;
+  function release() {
+    if (released) return;
+    released = true;
+    if (timer) clearInterval(timer);
+    binding.release();
+  }
+  function check() {
+    if (released) return true;
+    if (binding.acknowledged()) { release(); return true; }
+    try {
+      if (paneInfo(paneTarget).dead) { release(); return true; }
+    } catch {
+      // Even a missing pane/server does not prove its child process exited:
+      // a tmux crash can leave an orphan bootstrap alive. Retain the FD.
+    }
+    return false;
+  }
+  timer = setInterval(check, intervalMs);
+  timer.unref?.();
+  check();
+  return { check, pending: () => !released };
+}
+
+export function runPinnedTmuxNewSession({ cwd, expectedIdentity, shell, command, env, sessionName, tmuxEnv },
+  { run = runTmux, paneInfo = tmuxPaneInfo, bootstrapCwd } = {}) {
+  const binding = preparePinnedCwdLaunch(cwd, shell, ['-c', command], {
+    env, expectedIdentity, acknowledge: true, ...(bootstrapCwd ? { bootstrapCwd } : {})
+  });
+  let args;
+  try {
+    // Multiple shell-command arguments make tmux exec the command directly,
+    // without its default shell or shell startup hooks running before pinning.
+    args = ['new-session', '-d', '-s', sessionName, '-c', binding.cwd,
+      ...tmuxEnvironmentArgs(tmuxEnv), '--',
+      ...isolatedEnvCommandArgs(binding.env), binding.command, ...binding.args];
+  } catch (error) {
+    binding.release();
+    throw error;
+  }
+  try {
+    run(args);
+  } catch (error) {
+    // A timed-out tmux command may have created the pane. Do not release its
+    // directory FD until a checked bootstrap ACK or definitive pane exit.
+    monitorPinnedTmuxLaunch(binding, `${sessionName}:0.0`, { paneInfo });
+    throw error;
+  }
+  return monitorPinnedTmuxLaunch(binding, `${sessionName}:0.0`, { paneInfo });
+}
+
 export function createTmuxSessions(deps) {
   const {
-    ctx, sessions,
+    ctx, sessions, isStopping = () => false,
     broadcast, closeSessionClients, hasOpenClients,
     sessionKey, sessionsForProject, resolveSessionPeerId,
     startTmuxStream, stopTmuxStream, refreshTmuxSnapshot,
@@ -41,7 +99,7 @@ export function createTmuxSessions(deps) {
     requestActorPeer, requestSource,
     upsertPeer, upsertCanonicalPeerBinding,
     findProviderSessionBinding, providerOwnerEvidenceFromDb,
-    shellCommand, detectBranch
+    detectBranch
   } = deps;
   const adoptionPaneInfo = deps.tmuxPaneInfo || tmuxPaneInfo;
   const adoptionSessionNames = deps.tmuxListSessionNames || tmuxListSessionNames;
@@ -533,6 +591,7 @@ export function createTmuxSessions(deps) {
   }
 
   function attachTmuxSession(input) {
+    if (isStopping()) throw new CliError('RUNTIME_STOPPING', 'Web runtime is stopping');
     const pctx = input.projectCtx || ctx;
     const id = input.id;
     if (!id) throw new CliError('BAD_REQUEST', 'id required');
@@ -653,6 +712,7 @@ export function createTmuxSessions(deps) {
     // Detect pane death (retry 3 times before detaching — handles Ctrl+C transient states)
     let deadCount = 0;
     session.exitPoller = setInterval(() => {
+      if (isStopping()) return;
       try {
         const fresh = tmuxPaneInfo(session.pane);
         if (fresh.dead) {
@@ -801,7 +861,7 @@ export function createTmuxSessions(deps) {
 
   function writeSessionInput(session, data) {
     if (session.type === 'external') {
-      fs.appendFileSync(session.inFile, data);
+      fs.appendFileSync(session.inFile, data, { mode: 0o600 });
     } else if (session.type === 'tmux') {
       tmuxSendLiteral(session.pane, data);
       scheduleTmuxInputRefresh(session);
@@ -812,17 +872,17 @@ export function createTmuxSessions(deps) {
   }
 
   function scheduleTmuxInputRefresh(session) {
-    if (session.type !== 'tmux' || !session.pane) return;
+    if (isStopping() || session.type !== 'tmux' || !session.pane) return;
     if (session.inputRefreshTimer) return;
     session.inputRefreshTimer = setTimeout(() => {
       session.inputRefreshTimer = null;
-      if (session.status === 'running') broadcast(session, { type: 'replace', data: refreshTmuxSnapshot(session) });
+      if (!isStopping() && session.status === 'running') broadcast(session, { type: 'replace', data: refreshTmuxSnapshot(session) });
     }, 80);
   }
 
   function resizeSession(session, cols, rows) {
     if (session.type === 'external') {
-      try { fs.appendFileSync(session.resizeFile, JSON.stringify({ cols, rows }) + '\n'); } catch {}
+      try { fs.appendFileSync(session.resizeFile, JSON.stringify({ cols, rows }) + '\n', { mode: 0o600 }); } catch {}
     } else if (session.type === 'tmux') {
       // Resize the tmux window to match the browser terminal so the captured
       // mirror has identical geometry — a prerequisite for accurate cursor
@@ -844,6 +904,7 @@ export function createTmuxSessions(deps) {
   }
 
   function startTmuxManagedSession(input) {
+    if (isStopping()) throw new CliError('RUNTIME_STOPPING', 'Web runtime is stopping');
     for (const existing of sessions.values()) {
       if (providerSessionBindingMatches(existing.binding, input.binding)) input.authorizeMutation?.(existing);
     }
@@ -859,6 +920,9 @@ export function createTmuxSessions(deps) {
     const role = input.role || 'peer';
     const command = input.command || defaultSessionCommand(kind);
     const cwd = path.resolve(input.cwd || pctx.root);
+    const expectedCwdIdentity = input.cwdIdentity ||
+      (cwd === pctx.root ? pctx.rootIdentity || pctx.initialRootIdentity : null) ||
+      captureSelectedCwdSnapshot(cwd);
     const sessionName = tmuxManagedSessionName(pctx, id);
     let paneTarget = `${sessionName}:0.0`;
     const callerEnv = input.env && typeof input.env === 'object' ? input.env : process.env;
@@ -867,7 +931,7 @@ export function createTmuxSessions(deps) {
       HCC_ROOT: pctx.root,
       HCC_DB: pctx.dbPath,
       TERM: 'xterm-256color'
-    }, callerEnv);
+    }, callerEnv, { rootIdentity: pctx.rootIdentity || pctx.initialRootIdentity });
     env[LAUNCH_FINGERPRINT_ENV] = launchFingerprint({ command, cwd, env });
     let hasSession = tmuxHasSession(sessionName);
     const relaunchableProvider = isRelaunchableProviderSession(kind, command, input.binding || {});
@@ -1040,14 +1104,14 @@ export function createTmuxSessions(deps) {
     try {
       if (!hasSession) {
         const shell = callerEnv.SHELL || process.env.SHELL || 'bash';
-        const launch = shellCommand([...isolatedEnvCommandArgs(env), shell, '-c', command]);
         const tmuxEnv = {
           HCC_ROOT: pctx.root,
           HCC_DB: pctx.dbPath,
           [LAUNCH_FINGERPRINT_ENV]: env[LAUNCH_FINGERPRINT_ENV]
         };
         if (relaunchableProvider) tmuxEnv[PROVIDER_STATE_ENV] = 'starting';
-        runTmux(['new-session', '-d', '-s', sessionName, '-c', cwd, ...tmuxEnvironmentArgs(tmuxEnv), launch]);
+        runPinnedTmuxNewSession({ cwd, expectedIdentity: expectedCwdIdentity,
+          shell, command, env, sessionName, tmuxEnv });
         createdTmuxSession = true;
       }
 

package/lib/web/tmux-stream.mjs

@@ -5,6 +5,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
+import { performance } from 'node:perf_hooks';
 import { runTmux, tmuxCapturePane, tmuxCursorInfo, tmuxCursorPayload } from '../terminal/tmux.mjs';
 import { CliError } from '../shared/errors.mjs';
 import { ensurePrivateProjectBufferDirectory } from '../runtime/project-path.mjs';
@@ -15,7 +16,8 @@ export function createTmuxStream({
   refreshPeerIoHeartbeat,
   withBufferDirectoryLease,
   shellQuoteArg,
-  ctx
+  ctx,
+  isStopping = () => false
 }) {
   function cursorEscape(payload) {
     if (!payload) return '';
@@ -24,6 +26,7 @@ export function createTmuxStream({
   }
 
   function tmuxSnapshot(session) {
+    if (isStopping()) return session.buffer || '';
     const captured = tmuxCapturePane(session.pane);
     return captured + cursorEscape(tmuxCursorPayload(captured, tmuxCursorInfo(session.pane)));
   }
@@ -39,16 +42,18 @@ export function createTmuxStream({
   }
 
   function scheduleTmuxReplace(session) {
-    if (session.type !== 'tmux' || !session.pane) return;
+    if (isStopping() || session.type !== 'tmux' || !session.pane) return;
     if (session.replaceTimer) clearTimeout(session.replaceTimer);
     session.replaceTimer = setTimeout(() => {
       session.replaceTimer = null;
+      if (isStopping()) return;
       session.lastBroadcastTime = Date.now();
       broadcast(session, { type: 'replace', data: refreshTmuxSnapshot(session) });
     }, 80);
   }
 
   function startTmuxReplacePoller(session, warning = null) {
+    if (isStopping()) return;
     if (session.replacePoller) clearInterval(session.replacePoller);
     if (warning) {
       session.warning = {
@@ -58,7 +63,7 @@ export function createTmuxStream({
     }
     session.lastBroadcastTime = Date.now();
     session.replacePoller = setInterval(() => {
-      if (session.status !== 'running') return;
+      if (isStopping() || session.status !== 'running') return;
       if (Date.now() - (session.lastBroadcastTime || 0) > 4000) {
         session.lastBroadcastTime = Date.now();
         broadcast(session, { type: 'replace', data: refreshTmuxSnapshot(session) });
@@ -67,6 +72,7 @@ export function createTmuxStream({
   }
 
   function startTmuxStream(session) {
+    if (isStopping()) throw new CliError('RUNTIME_STOPPING', 'Web runtime is stopping');
     const safePane = String(session.pane).replace(/[^A-Za-z0-9_-]/g, '');
     const safeId = String(session.id).replace(/[^A-Za-z0-9_.-]/g, '_');
     const streamDirectory = ensurePrivateProjectBufferDirectory((session.ctx || ctx).root);
@@ -106,6 +112,7 @@ export function createTmuxStream({
       return 'poll';
     }
     session.streamPoller = setInterval(() => {
+      if (isStopping()) return;
       try {
         if (session.streamFd === null || session.streamFd === undefined) return;
         const chunks = [];
@@ -141,21 +148,42 @@ export function createTmuxStream({
     return 'stream';
   }
 
-  function stopTmuxStream(session) {
+  function stopTmuxStream(session, { shutdownDeadline = null } = {}) {
+    const shuttingDown = Number.isFinite(shutdownDeadline);
+    const remaining = () => shuttingDown ? shutdownDeadline - performance.now() : Infinity;
     if (session.streamPoller) { clearInterval(session.streamPoller); session.streamPoller = null; }
     if (session.replacePoller) { clearInterval(session.replacePoller); session.replacePoller = null; }
     if (session.replaceTimer) { clearTimeout(session.replaceTimer); session.replaceTimer = null; }
     if (session.inputRefreshTimer) { clearTimeout(session.inputRefreshTimer); session.inputRefreshTimer = null; }
-    try { runTmux(['pipe-pane', '-t', session.pane]); } catch {}
+    // Shutdown shares one budget across all sessions. Detach keeps its normal
+    // behavior, but advisory stream cleanup must not consume down's 5s wait
+    // once per pane. Never pass zero to spawnSync (it disables the timeout).
+    if (remaining() >= 1) {
+      try { runTmux(['pipe-pane', '-t', session.pane], shuttingDown
+        ? { timeout: Math.max(1, Math.min(250, Math.floor(remaining()))) } : {}); } catch {}
+    }
+    let originalPipe = null;
     if (session.streamFd !== null && session.streamFd !== undefined) {
+      if (shuttingDown) {
+        try { originalPipe = fs.fstatSync(session.streamFd); } catch {}
+      }
       try { fs.closeSync(session.streamFd); } catch {}
       session.streamFd = null;
     }
     if (session.pipeFile) {
       try {
-        withBufferDirectoryLease(path.dirname(session.pipeFile), () => {
-          fs.unlinkSync(session.pipeFile);
-        });
+        if (remaining() >= 1 && (!shuttingDown || originalPipe?.isFIFO())) {
+          withBufferDirectoryLease(path.dirname(session.pipeFile), () => {
+            if (shuttingDown) {
+              if (remaining() < 1) return;
+              // Pointers may already be cleared. A successor can reuse this
+              // pathname, so only unlink the FIFO owned by our open descriptor.
+              const current = fs.lstatSync(session.pipeFile);
+              if (!current.isFIFO() || current.dev !== originalPipe.dev || current.ino !== originalPipe.ino) return;
+            }
+            fs.unlinkSync(session.pipeFile);
+          }, shuttingDown ? { nonblocking: true, createParent: false } : {});
+        }
       } catch {}
       session.pipeFile = null;
     }

package/lib/web/ui-agent-defaults.mjs

@@ -0,0 +1,149 @@
+export const agentDefaultsCss = `
+  .settings-dialog { width:min(700px,calc(100vw - 28px)); max-width:none; max-height:90dvh; overflow:auto; }
+  .agent-defaults { margin-top:22px; padding-top:18px; border-top:1px solid var(--border); display:grid; gap:12px; }
+  .agent-defaults h4,.agent-defaults p { margin:0; }
+  .agent-defaults fieldset { min-width:0; border:1px solid var(--border); border-radius:8px; padding:12px; display:grid; gap:10px; }
+  .agent-defaults legend { padding:0 6px; }
+  .agent-defaults label { min-width:0; }
+  .agent-defaults input,.agent-defaults select { width:100%; min-width:0; }
+  .agent-defaults .btns { flex-wrap:wrap; }
+  #agentDefaultsProject { overflow-wrap:anywhere; }
+  .agent-defaults [hidden] { display:none; }
+`;
+
+export function agentDefaultsHtml() {
+  const providerFields=[['Codex','Codex'],['Claude','Claude'],['Dsh','DeepSeek Harness']].map(([id,label]) =>
+    '<fieldset><legend>'+label+'</legend><label><span data-i18n="agent.model">Model (optional)</span><input id="agentDefaults'+id+'Model" type="text" maxlength="256" autocomplete="off" data-i18n-placeholder="agent.modelPlaceholder" placeholder="Provider default"></label>'
+    +'<label><span data-i18n="agentDefaults.cwd">Project relative working directory</span><input id="agentDefaults'+id+'Cwd" type="text" required autocomplete="off" placeholder="."></label></fieldset>').join('');
+  return `<form id="agentDefaultsForm" class="agent-defaults">
+    <h4 data-i18n="agentDefaults.title">Project Agent defaults</h4><p id="agentDefaultsProject" class="dialog-help"></p>
+    <p class="dialog-help" data-i18n="agentDefaults.help">Saved for this project and used for new background Agents. Existing Agents, history restores, accounts and API keys are unchanged.</p>
+    <label><span data-i18n="agentDefaults.provider">Default Agent</span><select id="agentDefaultsProvider"><option value="codex">Codex</option><option value="claude">Claude</option><option value="dsh">DeepSeek Harness</option></select></label>
+    ${providerFields}
+    <p class="dialog-help" data-i18n="agentDefaults.fieldsHelp">Use . for the project directory. An empty model uses the provider default.</p>
+    <p id="agentDefaultsStatus" class="dialog-help" role="status" aria-live="polite"></p>
+    <div class="btns"><button id="agentDefaultsReload" type="button" data-i18n="agentDefaults.reload">Reload saved values</button><button id="agentDefaultsReset" type="button" data-i18n="agentDefaults.reset">Restore initial values</button><button id="agentDefaultsSave" type="submit" class="primary" data-i18n="agentDefaults.save">Save project defaults</button></div>
+  </form>`;
+}
+
+export function installAgentDefaults(browser = globalThis) {
+  const {window,document}=browser, bridge=window.hccHandoff, node=id=>document.getElementById(id);
+  const providers=[['codex','Codex'],['claude','Claude'],['dsh','Dsh']], records=new Map();
+  const fields=['agentDefaultsProvider',...providers.flatMap(([,label])=>['agentDefaults'+label+'Model','agentDefaults'+label+'Cwd'])];
+  let record=null, visit=0;
+  const empty=()=>({defaultProvider:'codex',providers:Object.fromEntries(providers.map(([provider])=>[provider,{model:null,cwd:'.'}]))});
+  const copy=value=>JSON.parse(JSON.stringify(value));
+  const values=value=>({defaultProvider:value.defaultProvider,providers:copy(value.providers)});
+  const signature=value=>JSON.stringify(values(value));
+  const route=root=>'/api/agent-defaults?root='+encodeURIComponent(root);
+  const visible=target=>record===target && target.root===bridge.projectRoot && !node('settingsDialog').hidden;
+  const tr=key=>bridge.tr(key);
+  function renderStatus() {
+    if (!record) return;
+    const message=tr(record.status || 'agentDefaults.ready');
+    node('agentDefaultsStatus').textContent=message+(record.error ? ' '+record.error : '');
+  }
+  function sync() {
+    if (!node('settingsDialog').hidden && (!record || record.root!==bridge.projectRoot)) { open(); return; }
+    if (!record) return;
+    const blocked=!record.loaded || record.loading || record.root!==bridge.projectRoot;
+    for (const id of fields) node(id).disabled=blocked;
+    node('agentDefaultsSave').disabled=blocked || record.saving || record.conflict || record.uncertain || !record.dirty;
+    node('agentDefaultsReset').disabled=blocked || record.saving;
+    node('agentDefaultsReload').disabled=record.loading || record.saving || !record.root;
+    node('agentDefaultsForm').setAttribute('aria-busy',String(record.loading || record.saving));
+    renderStatus();
+  }
+  function render() {
+    if (!record) return;
+    node('agentDefaultsProject').textContent=record.root;
+    node('agentDefaultsProvider').value=record.value.defaultProvider;
+    for (const [provider,label] of providers) {
+      node('agentDefaults'+label+'Model').value=record.value.providers[provider].model || '';
+      node('agentDefaults'+label+'Cwd').value=record.value.providers[provider].cwd;
+    }
+    sync();
+  }
+  function changed() {
+    if (!record || !record.loaded || record.loading || record.root!==bridge.projectRoot) return;
+    record.value={defaultProvider:node('agentDefaultsProvider').value,providers:Object.fromEntries(providers.map(([provider,label])=>[provider,{
+      model:node('agentDefaults'+label+'Model').value.trim() || null,cwd:node('agentDefaults'+label+'Cwd').value.trim()
+    }]))};
+    record.dirty=signature(record.value)!==record.saved;
+    if (!record.conflict && !record.uncertain && !record.saving) { record.status=record.dirty ? 'agentDefaults.unsaved' : 'agentDefaults.ready'; record.error=''; }
+    sync();
+  }
+  async function read(root=bridge.projectRoot) {
+    if (!root) throw new Error(tr('agentDefaults.projectLoading'));
+    return bridge.api(route(root));
+  }
+  async function reload() {
+    if (!record || record.loading || record.saving || !record.root) return;
+    const target=record, version=visit;
+    target.loadVersion=version;
+    target.loading=true; target.status='agentDefaults.loading'; target.error=''; sync();
+    try {
+      const result=await read(target.root);
+      if (!visible(target) || version!==visit) return;
+      target.value=values(result); target.revision=result.revision; target.saved=signature(target.value);
+      target.loaded=true; target.dirty=false; target.conflict=false; target.uncertain=false; target.status='agentDefaults.ready';
+    } catch (error) {
+      if (visible(target) && version===visit) { target.status='agentDefaults.loadFailed'; target.error=error.detail || error.message; }
+    } finally {
+      if (target.loadVersion===version) target.loading=false;
+      if (visible(target) && version===visit) render();
+    }
+  }
+  function open() {
+    visit++;
+    const root=bridge.projectRoot;
+    if (!records.has(root)) records.set(root,{root,value:empty(),loaded:false,loading:false,saving:false,dirty:false,revision:null,status:'agentDefaults.ready',error:''});
+    record=records.get(root);
+    record.loading=false;
+    while (records.size>20) {
+      const removable=[...records.entries()].find(([key,value])=>key!==root && !value.saving && !value.dirty);
+      if (!removable) break;
+      records.delete(removable[0]);
+    }
+    if (!root) { record.status='agentDefaults.projectLoading'; render(); return; }
+    render();
+    if (!record.dirty && !record.saving && !record.conflict && !record.uncertain) void reload();
+  }
+  function closed() { visit++; }
+  function reset() { closed(); record=null; }
+  async function save(event) {
+    event?.preventDefault(); changed();
+    const target=record;
+    if (!target || !visible(target) || !target.loaded || target.loading || target.saving || target.conflict || target.uncertain || !target.dirty) return;
+    const submitted=copy(target.value), sentSignature=signature(submitted), revision=target.revision;
+    target.saving=true; target.status='agentDefaults.saving'; target.error=''; sync();
+    try {
+      const result=await bridge.api(route(target.root),{method:'PUT',body:JSON.stringify({revision,...submitted})});
+      target.revision=result.revision; target.saved=signature(result);
+      // The server receipt belongs to the submitted snapshot. Edits typed while
+      // it was saving remain a draft on top of the new revision.
+      if (signature(target.value)===sentSignature) target.value=values(result);
+      target.dirty=signature(target.value)!==target.saved;
+      target.status=target.dirty ? 'agentDefaults.savedWithEdits' : 'agentDefaults.saved';
+    } catch (error) {
+      target.error=error.detail || error.message;
+      if (error.status===409 || error.code==='AGENT_DEFAULTS_CONFLICT') { target.conflict=true; target.status='agentDefaults.conflict'; }
+      else if (!error.status || ['REQUEST_TIMEOUT','REQUEST_SUPERSEDED'].includes(error.code)) { target.uncertain=true; target.status='agentDefaults.uncertain'; }
+      else target.status='agentDefaults.saveFailed';
+    } finally {
+      target.saving=false;
+      if (visible(target)) render();
+    }
+  }
+  node('agentDefaultsForm').addEventListener('submit',save);
+  for (const id of fields) { node(id).addEventListener('input',changed); node(id).addEventListener('change',changed); }
+  node('agentDefaultsReload').addEventListener('click',reload);
+  node('agentDefaultsReset').addEventListener('click',()=>{
+    if (!record || !record.loaded || record.loading || record.saving || record.root!==bridge.projectRoot) return;
+    record.value=empty(); record.dirty=signature(record.value)!==record.saved;
+    if (!record.conflict && !record.uncertain) { record.status='agentDefaults.resetDraft'; record.error=''; }
+    render();
+  });
+  window.addEventListener('hcc:preferences',()=>{ if (record && visible(record)) sync(); });
+  window.hccAgentDefaults={open,closed,reset,sync,read};
+}