@logicseek/hello-cc 0.1.9 → 1.0.0

package/lib/core/peers/evidence-runtime.mjs

@@ -0,0 +1,312 @@
+// Runtime evidence helpers extracted from bin/hcc.mjs.
+// Process/tmux evidence observation, optimistic evidence-checked peer
+// mutation, and clock-safety observation adapters shared by web + GC.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { tx } from '../../db/schema.mjs';
+import {
+  clockSafetyUnavailable,
+  observeClockSafety,
+  observeClockSafetyInTransaction
+} from '../../core/coordination/clock-safety.mjs';
+import {
+  captureLockAcquireSubject,
+  clockCandidatesFromLocks,
+  observeLockOwnerEvidence
+} from '../../core/coordination/lock-evidence.mjs';
+import { resolvePeerEvidence } from '../../core/peers/evidence.mjs';
+import { inspectProcessIdentity } from '../../process/identity.mjs';
+import {
+  runTmux,
+  tmuxManagedSessionName,
+  tmuxManagedSessionNameMatches,
+  tmuxManagedSessionPrefixMatches,
+  tmuxPaneInfo,
+  tmuxSessionEnvironmentValue
+} from '../../tmux.mjs';
+
+export function createEvidenceRuntime({ now }) {
+function isProjectManagedTmuxSession(projectCtx, sessionName, sessionRoot = null) {
+  return tmuxManagedSessionPrefixMatches(projectCtx, sessionName, sessionRoot);
+}
+
+function liveProcessIdentity(pid) {
+  const inspected = inspectProcessIdentity(pid);
+  return inspected.state === 'live' ? inspected.identity : null;
+}
+
+function storedPeerIdentity(row) {
+  return row?.pid ? {
+    pid: Number(row.pid),
+    startToken: row.pid_start_token,
+    commandHash: row.pid_command_hash
+  } : null;
+}
+
+function processEvidenceFromRow(row, name = 'peer') {
+  return {
+    name,
+    storedIdentity: storedPeerIdentity(row),
+    current: inspectProcessIdentity(row?.pid)
+  };
+}
+
+function canonicalRoot(value) {
+  if (!value) return null;
+  try { return fs.realpathSync(value); }
+  catch {
+    try { return path.resolve(value); } catch { return null; }
+  }
+}
+
+function rootEvidence(expected, actual) {
+  const expectedRoot = canonicalRoot(expected);
+  const actualRoot = canonicalRoot(actual);
+  if (!expectedRoot || !actualRoot) {
+    return { state: 'unknown', expected: expectedRoot, actual: actualRoot };
+  }
+  return {
+    state: expectedRoot === actualRoot ? 'match' : 'mismatch',
+    expected: expectedRoot,
+    actual: actualRoot
+  };
+}
+
+function tmuxTargetMissing(error) {
+  return /can't find pane|can't find session|no server running/i.test(String(error?.message || ''));
+}
+
+function inspectTmuxTarget(expectedSession, target) {
+  let actualSession = null;
+  try {
+    actualSession = runTmux(['display-message', '-p', '-t', target, '#{session_name}']).trim() || null;
+  } catch (targetError) {
+    try {
+      runTmux(['has-session', '-t', expectedSession]);
+      actualSession = expectedSession;
+    } catch (sessionError) {
+      return {
+        session: { state: tmuxTargetMissing(sessionError) ? 'dead' : 'unknown', expected: expectedSession, actual: null },
+        pane: { state: tmuxTargetMissing(targetError) ? 'dead' : 'unknown', expected: target, actual: null },
+        paneInfo: null
+      };
+    }
+  }
+  if (!actualSession) {
+    try {
+      runTmux(['has-session', '-t', expectedSession]);
+      actualSession = expectedSession;
+    } catch (sessionError) {
+      return {
+        session: { state: tmuxTargetMissing(sessionError) ? 'dead' : 'unknown', expected: expectedSession, actual: null },
+        pane: { state: 'unknown', expected: target, actual: null },
+        paneInfo: null
+      };
+    }
+  }
+
+  try {
+    const paneInfo = tmuxPaneInfo(target);
+    const expectedPane = target === `${expectedSession}:0.0` ? paneInfo.pane : target;
+    return {
+      session: { state: 'live', expected: expectedSession, actual: actualSession },
+      pane: { state: paneInfo.dead ? 'dead' : 'live', expected: expectedPane, actual: paneInfo.pane },
+      paneInfo
+    };
+  } catch (error) {
+    return {
+      session: { state: 'live', expected: expectedSession, actual: actualSession },
+      pane: { state: tmuxTargetMissing(error) ? 'dead' : 'unknown', expected: target, actual: null },
+      paneInfo: null
+    };
+  }
+}
+
+function observePeerEvidence(projectCtx, row, binding = null) {
+  if (binding?.transport !== 'tmux') {
+    return resolvePeerEvidence({ peer: row, processes: [processEvidenceFromRow(row)] });
+  }
+
+  const expectedSession = tmuxManagedSessionName(projectCtx, row.id);
+  const runtimeTarget = binding.runtime_target || `${expectedSession}:0.0`;
+  const target = inspectTmuxTarget(expectedSession, runtimeTarget);
+  const panePid = target.paneInfo?.pid || row.pid;
+  const paneProcess = {
+    name: 'pane',
+    storedIdentity: Number(row?.pid) === Number(panePid) ? storedPeerIdentity(row) : null,
+    current: inspectProcessIdentity(panePid)
+  };
+  const actualRoot = target.session.actual
+    ? tmuxSessionEnvironmentValue(target.session.actual, 'HCC_ROOT')
+    : null;
+  if (target.session.actual && tmuxManagedSessionNameMatches(
+    projectCtx,
+    target.session.actual,
+    row.id,
+    actualRoot
+  )) {
+    target.session.expected = target.session.actual;
+  }
+  return resolvePeerEvidence({
+    peer: row,
+    processes: [processEvidenceFromRow(row, 'owner')],
+    tmux: {
+      managed: true,
+      session: target.session,
+      pane: target.pane,
+      root: rootEvidence(projectCtx.root, actualRoot),
+      process: paneProcess
+    }
+  });
+}
+
+function peerEvidenceFromDb(db, projectCtx, peerId) {
+  const row = db.prepare(`
+    SELECT id, status, pid, pid_start_token, pid_command_hash
+    FROM peers WHERE id = ?
+  `).get(peerId);
+  if (!row) return { state: 'unknown', reason: 'peer_missing' };
+  const binding = db.prepare(`
+    SELECT transport, runtime_target FROM peer_bindings WHERE peer = ?
+  `).get(peerId) || null;
+  return observePeerEvidence(projectCtx, row, binding);
+}
+
+function providerOwnerEvidenceFromDb(db, peerId) {
+  const row = db.prepare(`
+    SELECT id, status, pid, pid_start_token, pid_command_hash
+    FROM peers WHERE id = ?
+  `).get(peerId);
+  return row
+    ? resolvePeerEvidence({ peer: row, processes: [processEvidenceFromRow(row, 'provider-owner')] })
+    : { state: 'unknown', reason: 'peer_missing' };
+}
+
+function peerMutationSubject(db, peerId) {
+  const peer = db.prepare(`
+    SELECT id, status, pid, pid_start_token, pid_command_hash, last_seen_at
+    FROM peers WHERE id = ?
+  `).get(peerId) || null;
+  const binding = db.prepare(`
+    SELECT peer, transport, runtime_target, updated_at
+    FROM peer_bindings WHERE peer = ?
+  `).get(peerId) || null;
+  return { peer, binding };
+}
+
+function mutatePeerWithEvidence(db, projectCtx, peerId, mutate, options = {}) {
+  const acceptEvidence = typeof options.acceptEvidence === 'function'
+    ? options.acceptEvidence
+    : (evidence) => evidence.state === 'dead';
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    const subject = peerMutationSubject(db, peerId);
+    if (!subject.peer) return { changed: false, evidence: { state: 'unknown', reason: 'peer_missing' } };
+    const evidence = observePeerEvidence(projectCtx, subject.peer, subject.binding);
+    if (!acceptEvidence(evidence, subject)) return { changed: false, evidence };
+    let subjectChanged = false;
+    let blocked = false;
+    const changed = tx(db, () => {
+      if (options.beforeMutate?.({ subject, evidence }) === false) {
+        blocked = true;
+        return false;
+      }
+      const current = peerMutationSubject(db, peerId);
+      if (JSON.stringify(current) !== JSON.stringify(subject)) {
+        subjectChanged = true;
+        return false;
+      }
+      mutate(current, evidence);
+      return true;
+    });
+    if (blocked) return { changed: false, evidence, blocked: true };
+    if (!subjectChanged) return { changed, evidence };
+  }
+  return { changed: false, evidence: { state: 'unknown', reason: 'subject_changed' } };
+}
+
+function mutateConfirmedDeadPeer(db, projectCtx, peerId, mutate, options = {}) {
+  return mutatePeerWithEvidence(db, projectCtx, peerId, mutate, options);
+}
+
+function observeClockSafetyOrThrow(db, options) {
+  try {
+    return observeClockSafety(db, options);
+  } catch (err) {
+    throw clockSafetyUnavailable(err);
+  }
+}
+
+function observeClockSafetyInTransactionOrThrow(db, options) {
+  try {
+    return observeClockSafetyInTransaction(db, options);
+  } catch (err) {
+    throw clockSafetyUnavailable(err);
+  }
+}
+
+function prepareLockClockObservation(db, subject, evidenceByOwner) {
+  return observeClockSafetyInTransactionOrThrow(db, {
+    operation: 'ownership',
+    candidates: clockCandidatesFromLocks(subject, evidenceByOwner),
+    nowSec: subject.observedAt
+  });
+}
+
+function observeLockClockSafety(db, projectCtx, {
+  requested = null,
+  taskId = null,
+  owner = null,
+  observedAt = now()
+} = {}) {
+  try {
+    const subject = captureLockAcquireSubject(db, {
+      taskId,
+      requested,
+      now: observedAt
+    });
+    const evidenceByOwner = observeLockOwnerEvidence(subject, (row, binding) =>
+      observePeerEvidence(projectCtx, row, binding));
+    const candidates = subject.locks
+      .filter((lock) => Number(lock.expires_at) <= observedAt && (!owner || lock.owner === owner))
+      .map((lock) => ({
+        boundary: Number(lock.expires_at),
+        evidence: evidenceByOwner.get(lock.owner)?.state || 'unknown',
+        owner: lock.owner,
+        resource: lock.resource
+      }));
+    return observeClockSafetyOrThrow(db, {
+      operation: 'ownership',
+      candidates,
+      nowSec: observedAt
+    });
+  } catch (err) {
+    throw clockSafetyUnavailable(err);
+  }
+}
+
+function observeTaskTakeoverClockSafety({ db, row, ownerRow, evidence, staleAfter }) {
+  const boundary = ownerRow
+    ? Number(ownerRow.last_seen_at || 0) + Number(staleAfter)
+    : 0;
+  return observeClockSafetyOrThrow(db, {
+    operation: 'ownership',
+    candidates: row?.owner ? [{
+      boundary,
+      evidence: evidence?.state || 'unknown',
+      owner: row.owner
+    }] : [],
+    nowSec: now()
+  });
+}
+
+  return {
+    isProjectManagedTmuxSession, liveProcessIdentity, storedPeerIdentity,
+    processEvidenceFromRow, canonicalRoot, rootEvidence, tmuxTargetMissing,
+    inspectTmuxTarget, observePeerEvidence, peerEvidenceFromDb,
+    providerOwnerEvidenceFromDb, peerMutationSubject, mutatePeerWithEvidence,
+    mutateConfirmedDeadPeer, observeClockSafetyOrThrow,
+    observeClockSafetyInTransactionOrThrow, prepareLockClockObservation,
+    observeLockClockSafety, observeTaskTakeoverClockSafety
+  };
+}

package/lib/core/peers/evidence.mjs

@@ -0,0 +1,103 @@
+import { compareProcessIdentity } from '../../process/identity.mjs';
+
+const DEFAULT_ACTIVE_PEER_TTL = 600;
+
+export function classifyPeerActivity(peer = {}, options = {}) {
+  const activePeerTtl = Number(options.activePeerTtl ?? DEFAULT_ACTIVE_PEER_TTL);
+  const graceActive = Boolean(options.graceActive);
+  const evidenceState = peer.evidence_state || peer.evidence?.state || 'unknown';
+  const age = Number(peer.age_sec);
+  const active = evidenceState === 'live' ||
+    (evidenceState !== 'dead' && (graceActive || (Number.isFinite(age) && age <= activePeerTtl)));
+  return { active, stale: !active };
+}
+
+export function peerEvidenceAllowsReap(evidence = {}, options = {}) {
+  if (evidence.state === 'dead') return true;
+  if (evidence.state !== 'unknown') return false;
+  const nowSec = Number(options.nowSec);
+  const lastSeenAt = Number(options.lastSeenAt);
+  const staleAfterSec = Number(options.staleAfterSec);
+  const graceUntil = Number(options.graceUntil ?? 0);
+  if (![nowSec, lastSeenAt, staleAfterSec, graceUntil].every((value) =>
+    Number.isSafeInteger(value) && value >= 0)) return false;
+  return nowSec - lastSeenAt >= staleAfterSec && nowSec >= graceUntil;
+}
+
+function processState(evidence) {
+  if (!evidence) return 'unknown';
+  if (compareProcessIdentity(evidence.storedIdentity, evidence.storedIdentity) !== 'live') {
+    // CS-06: no usable stored fingerprint (legacy row without pid_start_token /
+    // pid_command_hash, or a missing pid). We cannot claim ownership — but a
+    // process that is demonstrably gone is still a dead process, so such peers
+    // are reaped once their process exits. A live-but-unverifiable process
+    // stays 'unknown' (protected).
+    return evidence.current?.state === 'dead' ? 'dead' : 'unknown';
+  }
+  if (evidence.current?.state === 'unknown') return 'unknown';
+  if (evidence.current?.state === 'dead') return 'dead';
+  if (evidence.current?.state !== 'live') return 'unknown';
+  return compareProcessIdentity(evidence.storedIdentity, evidence.current.identity);
+}
+
+function aggregateProcesses(processes) {
+  if (!Array.isArray(processes) || processes.length === 0) {
+    return { state: 'unknown', reason: 'process_evidence_missing' };
+  }
+  const states = processes.map(processState);
+  if (states.includes('live')) {
+    return { state: 'live', reason: 'process_identity_match' };
+  }
+  if (states.every((state) => state === 'dead')) {
+    const missing = processes.every((item) => item?.current?.state === 'dead');
+    return {
+      state: 'dead',
+      reason: missing ? 'process_missing' : 'process_identity_mismatch'
+    };
+  }
+  return { state: 'unknown', reason: 'process_identity_incomplete' };
+}
+
+function tmuxProcessState(tmux) {
+  return processState(tmux?.process);
+}
+
+function tmuxConfirmedDead(tmux) {
+  const exactSession = tmux?.session?.state === 'live' &&
+    tmux?.session?.expected === tmux?.session?.actual;
+  return tmux?.session?.state === 'dead' ||
+    (exactSession && tmux?.pane?.state === 'dead');
+}
+
+function tmuxVerifiedLive(tmux) {
+  return tmux?.session?.state === 'live' &&
+    tmux?.session?.expected === tmux?.session?.actual &&
+    tmux?.pane?.state === 'live' &&
+    tmux?.pane?.expected === tmux?.pane?.actual &&
+    tmux?.root?.state === 'match' &&
+    tmuxProcessState(tmux) === 'live';
+}
+
+export function resolvePeerEvidence(input = {}) {
+  const ordinaryProcess = aggregateProcesses(input.processes);
+  if (ordinaryProcess.state === 'live') return ordinaryProcess;
+
+  const tmux = input.tmux?.managed ? input.tmux : null;
+  if (ordinaryProcess.state === 'unknown' && tmux && tmuxVerifiedLive(tmux)) {
+    return { state: 'live', reason: 'tmux_identity_match' };
+  }
+
+  if (input.peer?.status === 'exited') {
+    return { state: 'dead', reason: 'explicit_exited' };
+  }
+  if (ordinaryProcess.state === 'dead' || !tmux) return ordinaryProcess;
+
+  if (tmux.root?.state === 'mismatch') {
+    return { state: 'unknown', reason: 'tmux_root_mismatch' };
+  }
+  const paneProcess = tmuxProcessState(tmux);
+  if (tmuxConfirmedDead(tmux) && paneProcess === 'dead') {
+    return { state: 'dead', reason: 'tmux_and_process_dead' };
+  }
+  return { state: 'unknown', reason: 'tmux_evidence_incomplete' };
+}

package/lib/core/peers/hook-owner.mjs

@@ -0,0 +1,32 @@
+function requireObservedAt(value) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new TypeError('observedAt must be a non-negative safe integer');
+  }
+  return value;
+}
+
+export function refreshHookOwnerIdentity(db, {
+  peerId,
+  status = null,
+  observedAt,
+  processIdentity = null
+} = {}) {
+  if (!db || typeof db.prepare !== 'function') throw new TypeError('db is required');
+  if (typeof peerId !== 'string' || !peerId) throw new TypeError('peerId is required');
+  const timestamp = requireObservedAt(observedAt);
+  if (!processIdentity) {
+    return db.prepare(`
+      UPDATE peers
+      SET last_seen_at = ?, status = COALESCE(?, status), pid = NULL,
+          pid_start_token = NULL, pid_command_hash = NULL
+      WHERE id = ?
+    `).run(timestamp, status, peerId).changes;
+  }
+  return db.prepare(`
+    UPDATE peers
+    SET last_seen_at = ?, status = COALESCE(?, status), pid = ?,
+        pid_start_token = ?, pid_command_hash = ?
+    WHERE id = ?
+  `).run(timestamp, status, processIdentity.pid, processIdentity.startToken,
+    processIdentity.commandHash, peerId).changes;
+}

package/lib/core/peers/liveness.mjs

@@ -1,9 +1,32 @@
 const DEFAULT_ACTIVE_PEER_TTL = 600;
 
+import { clockGraceSuppressed } from '../../shared/clock-grace.mjs';
+import { inspectProcessIdentity } from '../../process/identity.mjs';
+import { classifyPeerActivity, resolvePeerEvidence } from './evidence.mjs';
+
 function nowSec() {
   return Math.floor(Date.now() / 1000);
 }
 
+function rowEvidence(row) {
+  if (row?.evidence_state) {
+    return { state: row.evidence_state, reason: row.evidence_reason || 'observed' };
+  }
+  const storedIdentity = row?.pid ? {
+    pid: Number(row.pid),
+    startToken: row.pid_start_token,
+    commandHash: row.pid_command_hash
+  } : null;
+  return resolvePeerEvidence({
+    peer: row,
+    processes: row?.pid ? [{
+      name: 'peer',
+      storedIdentity,
+      current: inspectProcessIdentity(row.pid)
+    }] : []
+  });
+}
+
 export function taskRelatedLocks(task, locks) {
   const taskId = Number(task?.id || 0);
   const owner = task?.owner || '';
@@ -13,7 +36,7 @@ export function taskRelatedLocks(task, locks) {
   });
 }
 
-export function taskOwnerLiveness(task, peers, locks, t = nowSec(), activePeerTtl = DEFAULT_ACTIVE_PEER_TTL) {
+export function taskOwnerLiveness(task, peers, locks, t = nowSec(), activePeerTtl = DEFAULT_ACTIVE_PEER_TTL, graceUntil = 0) {
   const owner = task?.owner || null;
   const relatedLocks = taskRelatedLocks(task, locks);
   if (!owner) {
@@ -22,6 +45,8 @@ export function taskOwnerLiveness(task, peers, locks, t = nowSec(), activePeerTt
       owner_active: null,
       owner_stale: false,
       owner_age_sec: null,
+      owner_evidence_state: 'unknown',
+      owner_evidence_reason: 'owner_missing',
       related_lock_count: relatedLocks.length,
       takeover_ready: false
     };
@@ -30,7 +55,18 @@ export function taskOwnerLiveness(task, peers, locks, t = nowSec(), activePeerTt
   const ownerAge = ownerRow
     ? Number(ownerRow.age_sec ?? (t - Number(ownerRow.last_seen_at || 0)))
     : null;
-  const ownerActive = Boolean(ownerRow && Number.isFinite(ownerAge) && ownerAge <= activePeerTtl);
+  const evidence = ownerRow ? rowEvidence(ownerRow) : { state: 'unknown', reason: 'peer_missing' };
+  // hb-05: after a wall-clock jump (sleep/NTP), age is untrustworthy for the
+  // grace window; treat every owner as active so a live owner's task is never
+  // spuriously marked stale/takeover-able.
+  const graceActive = clockGraceSuppressed(t, graceUntil);
+  const activity = classifyPeerActivity({
+    ...ownerRow,
+    age_sec: ownerAge,
+    evidence_state: evidence.state,
+    evidence_reason: evidence.reason
+  }, { activePeerTtl, graceActive });
+  const ownerActive = Boolean(ownerRow && activity.active);
   const ownerStale = !ownerActive;
   const takeoverStatus = ['claimed', 'running', 'review', 'blocked'].includes(task.status);
   return {
@@ -38,15 +74,17 @@ export function taskOwnerLiveness(task, peers, locks, t = nowSec(), activePeerTt
     owner_active: ownerActive,
     owner_stale: ownerStale,
     owner_age_sec: Number.isFinite(ownerAge) ? ownerAge : null,
+    owner_evidence_state: evidence.state,
+    owner_evidence_reason: evidence.reason,
     related_lock_count: relatedLocks.length,
     takeover_ready: Boolean(takeoverStatus && ownerStale && relatedLocks.length === 0)
   };
 }
 
-export function annotateTasksWithLiveness(tasks, peers, locks, t = nowSec(), activePeerTtl = DEFAULT_ACTIVE_PEER_TTL) {
+export function annotateTasksWithLiveness(tasks, peers, locks, t = nowSec(), activePeerTtl = DEFAULT_ACTIVE_PEER_TTL, graceUntil = 0) {
   return (tasks || []).map((task) => ({
     ...task,
-    ...taskOwnerLiveness(task, peers, locks, t, activePeerTtl)
+    ...taskOwnerLiveness(task, peers, locks, t, activePeerTtl, graceUntil)
   }));
 }
 
@@ -75,6 +113,8 @@ export function summarizeTask(task) {
     owner_active: task.owner_active ?? null,
     owner_stale: Boolean(task.owner_stale),
     owner_age_sec: task.owner_age_sec ?? null,
+    owner_evidence_state: task.owner_evidence_state || 'unknown',
+    owner_evidence_reason: task.owner_evidence_reason || null,
     related_lock_count: Number(task.related_lock_count || 0),
     takeover_ready: Boolean(task.takeover_ready)
   };

package/lib/core/peers/peer-helpers.mjs

@@ -0,0 +1,121 @@
+// Peer upsert/touch helpers extracted from bin/hcc.mjs.
+// Factory pattern: callers inject the functions that remain in bin/hcc.mjs.
+
+export function createPeerHelpers({
+  now,
+  addEvent,
+  liveProcessIdentity,
+  detectBranch,
+  registerProjectActivity,
+  upsertCanonicalPeerBinding,
+  autoPeerKind,
+  autoPeerSessionId,
+  autoPeerResumeId,
+  autoPeerDefaults,
+  autoPeerBasis,
+  providerSessionParts
+}) {
+  function upsertPeer(db, peer) {
+    const t = now();
+    const identity = Object.hasOwn(peer, 'processIdentity')
+      ? peer.processIdentity
+      : liveProcessIdentity(peer.pid);
+    db.prepare(`
+      INSERT INTO peers(id, kind, role, worktree, branch, pid, pid_start_token, pid_command_hash, status, capabilities, created_at, last_seen_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET
+        kind = excluded.kind,
+        role = excluded.role,
+        worktree = excluded.worktree,
+        branch = excluded.branch,
+        pid = excluded.pid,
+        pid_start_token = excluded.pid_start_token,
+        pid_command_hash = excluded.pid_command_hash,
+        -- hb-08: an incidental upsert with the default 'idle' status must not
+        -- resurrect a peer that was explicitly marked exited/detached.
+        status = CASE WHEN excluded.status = 'idle' AND peers.status IN ('exited', 'detached')
+                      THEN peers.status ELSE excluded.status END,
+        capabilities = excluded.capabilities,
+        last_seen_at = excluded.last_seen_at
+    `).run(
+      peer.id,
+      peer.kind || 'other',
+      peer.role || '',
+      peer.worktree || '',
+      peer.branch || '',
+      peer.pid || null,
+      identity?.startToken || null,
+      identity?.commandHash || null,
+      peer.status || 'idle',
+      peer.capabilities || '',
+      t,
+      t
+    );
+  }
+
+  function touchPeer(db, id, status = null) {
+    if (!id) return;
+    const existing = db.prepare('SELECT id FROM peers WHERE id = ?').get(id);
+    if (!existing) {
+      upsertPeer(db, {
+        id,
+        kind: 'other',
+        role: 'auto',
+        worktree: process.cwd(),
+        branch: detectBranch(process.cwd()),
+        pid: process.ppid,
+        status: status || 'idle',
+        capabilities: ''
+      });
+    } else {
+      db.prepare(`
+        UPDATE peers
+        SET last_seen_at = ?, status = COALESCE(?, status)
+        WHERE id = ?
+      `).run(now(), status, id);
+    }
+  }
+
+  function touchCurrentPeer(db, ctx, resolved, status = null, kindHint = 'shell') {
+    registerProjectActivity(ctx);
+    const identity = typeof resolved === 'string'
+      ? { id: resolved, auto: false }
+      : resolved;
+    if (!identity || !identity.id) return;
+    if (!identity.auto) {
+      touchPeer(db, identity.id, status);
+      return;
+    }
+
+    const existing = db.prepare('SELECT id FROM peers WHERE id = ?').get(identity.id);
+    if (existing) {
+      touchPeer(db, identity.id, status);
+      return;
+    }
+
+    const kind = autoPeerKind(kindHint);
+    const sessionId = autoPeerSessionId(kind);
+    const resumeId = autoPeerResumeId(kind);
+    upsertPeer(db, {
+      id: identity.id,
+      ...autoPeerDefaults(ctx, kindHint, status || 'idle')
+    });
+    upsertCanonicalPeerBinding(db, {
+      peer: identity.id,
+      provider: kind,
+      ...providerSessionParts(resumeId || sessionId),
+      resume_mode: resumeId ? 'resume' : (sessionId ? 'detected' : 'auto'),
+      resume_arg: resumeId || null,
+      command: null,
+      transport: process.env.TMUX_PANE ? 'auto-tmux' : 'auto-shell',
+      runtime_session_id: identity.id
+    }, true);
+    addEvent(db, 'peer.auto_joined', identity.id, null, {
+      root: ctx.root,
+      basis: autoPeerBasis(kind),
+      provider_session: resumeId || sessionId || null
+    });
+  }
+
+  return { upsertPeer, touchPeer, touchCurrentPeer };
+}

package/lib/core/peers/session.mjs

@@ -1,7 +1,13 @@
-import { sanitizePeerPart, shortHash } from './format.mjs';
+import { shortHash } from './format.mjs';
 
+// sess-04: derive the peer id from a sha1 hash of the FULL provider session
+// id/name, not the first 8 raw chars — name-based ids that share a prefix
+// (e.g. codex `feature-login` vs `feature-logout`) used to collide into the
+// same peer id. The shim script derives the identical value (see
+// lib/integrations/shims/script.mjs peer_hash). NOTE: this changes existing
+// peer ids for name-based resumes (pre-1.0 intentional identity change).
 export function providerSessionPeerId(kind, providerId) {
-  return `${kind}-${sanitizePeerPart(String(providerId || '').slice(0, 8), shortHash(providerId))}`;
+  return `${kind}-${shortHash(String(providerId || ''))}`;
 }
 
 export function providerSessionParts(value) {