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

package/lib/integrations/native/codex.mjs

@@ -1,9 +1,12 @@
 import { JsonRpcProcess } from './jsonrpc.mjs';
+import { createCodexAccountState } from '../codex-account.mjs';
 import { createNativeInteractions } from './interactions.mjs';
+import { codexUsage } from './telemetry.mjs';
+import { captureSelectedCwdIdentity } from '../../process/selected-cwd-identity.mjs';
 import { CODEX_INTERACTION_METHODS, codexInteractionKind, codexInteractionResponse, cancelCodexInteraction, codexInteractiveConfig } from '../codex-interactions.mjs';
 
 const CAPABILITIES = Object.freeze({ create: true, resume: true, send: true, observe: true,
-  steer: true, interrupt: true, close: true, fork: false });
+  steer: true, interrupt: true, close: true, fork: false, accountRead: true });
 const TERMINAL_TURN_STATUSES = new Set(['completed', 'interrupted', 'failed']);
 
 function adapterError(code, message) {
@@ -14,6 +17,7 @@ function adapterError(code, message) {
 export function createCodexAdapter(options = {}) {
   const { binary = 'codex', cwd, env, timeoutMs = 30_000, onEvent = () => {},
     rpcFactory = (config) => new JsonRpcProcess(config) } = options;
+  const cwdBinding = cwd ? captureSelectedCwdIdentity(cwd, options.expectedCwdIdentity) : null;
   const state = { provider: 'codex', sessionId: null, turnId: null, status: 'new', owned: true };
   const terminalTurns = new Set();
   const interruptedTurns = new Set();
@@ -24,6 +28,8 @@ export function createCodexAdapter(options = {}) {
   let admission = Promise.resolve();
   let pendingSubmissionId;
   let closePromise;
+  const account = createCodexAccountState({ request: (method, params) => rpc.request(method, params),
+    onChange: value => emit({ type: 'account', account: value }) });
   const capabilities = { ...CAPABILITIES, approvals: Boolean(options.interactive), userInput: Boolean(options.interactive), mcp: Boolean(options.mcpServers) };
   const interactions = createNativeInteractions({ executorId: options.executorId,
     isActive: (sessionId, turnId) => !closed && sessionId === state.sessionId && turnId === state.turnId && !terminalTurns.has(turnId) && !interruptedTurns.has(turnId) && !['error', 'uncertain', 'closed'].includes(state.status),
@@ -55,10 +61,13 @@ export function createCodexAdapter(options = {}) {
   }
 
   function notification(method, params = {}) {
-    if (closed || !state.sessionId || params.threadId !== state.sessionId) return;
+    if (closed || account.notification(method, params) || !state.sessionId || params.threadId !== state.sessionId) return;
     const turnId = params.turn?.id ?? params.turnId;
     const submissionId = turnSubmissions.get(turnId) ?? pendingSubmissionId;
-    if (method === 'turn/started' && turnId && !terminalTurns.has(turnId)) {
+    if (method === 'thread/tokenUsage/updated') {
+      const metrics = codexUsage(params);
+      if (metrics) { state.metrics = metrics; emit({ type: 'usage', metrics, turnId }); }
+    } else if (method === 'turn/started' && turnId && !terminalTurns.has(turnId)) {
       if (submissionId) turnSubmissions.set(turnId, submissionId);
       state.turnId = turnId;
       status('busy');
@@ -119,6 +128,8 @@ export function createCodexAdapter(options = {}) {
 
   function exited(details = {}) {
     if (closed) return;
+    cwdBinding?.release();
+    account.close();
     interactions.expire();
     state.turnId = null;
     status('error');
@@ -128,6 +139,7 @@ export function createCodexAdapter(options = {}) {
 
   function transportError(error) {
     if (closed) return;
+    account.close();
     interactions.expire();
     status('error');
     emit({ type: 'error', code: error.code ?? 'NATIVE_TRANSPORT_ERROR', text: error.message,
@@ -143,6 +155,7 @@ export function createCodexAdapter(options = {}) {
     }
     status('opening');
     try {
+      cwdBinding?.assertUnchanged();
       rpc = rpcFactory({ binary, args: ['app-server', '--stdio'], cwd, env, timeoutMs,
         onNotification: notification, onRequest: serverRequest, onExit: exited, onError: transportError });
       await rpc.start();
@@ -156,12 +169,16 @@ export function createCodexAdapter(options = {}) {
       const params = { sandbox: 'workspace-write', approvalPolicy: 'on-request', approvalsReviewer: 'user',
         ...(Object.keys(config).length ? { config } : {}),
         ...(cwd ? { cwd } : {}), ...(model ? { model } : {}), ...(sessionId ? { threadId: sessionId } : {}) };
+      cwdBinding?.assertUnchanged();
       const response = await rpc.request(sessionId ? 'thread/resume' : 'thread/start', params);
       if (!response?.thread?.id || (sessionId && response.thread.id !== sessionId)) {
         throw adapterError('NATIVE_PROTOCOL_ERROR', 'Codex returned an invalid native thread identity.');
       }
       if (closed) throw adapterError('NATIVE_SESSION_CLOSED', 'The Codex session was closed while opening.');
       state.sessionId = response.thread.id;
+      state.runtimeMetadata = { ...(typeof response.model === 'string' ? { model: response.model } : {}),
+        ...(typeof response.approvalPolicy === 'string' ? { permissionMode: response.approvalPolicy } : {}) };
+      emit({ type: 'metadata', runtimeMetadata: state.runtimeMetadata });
       const activeTurn = response.thread.turns?.findLast((turn) => turn.status === 'inProgress');
       state.turnId = activeTurn?.id ?? null;
       status(state.turnId ? 'busy' : 'idle');
@@ -229,14 +246,28 @@ export function createCodexAdapter(options = {}) {
   function close() {
     if (closePromise) return closePromise;
     closed = true;
+    account.close();
     interactions.expire();
     state.turnId = null;
-    status('closed');
-    closePromise = Promise.resolve().then(() => rpc?.close()).then(() => snapshot());
+    status('closing');
+    closePromise = Promise.resolve().then(() => rpc?.close()).then(() => {
+      cwdBinding?.release();
+      status('closed');
+      return snapshot();
+    }).catch((error) => {
+      cwdBinding?.release();
+      // Keep admissions revoked while allowing owned-process cleanup to retry.
+      status('uncertain');
+      closePromise = null;
+      throw error;
+    });
     return closePromise;
   }
 
-  function snapshot() { return { ...state, executorId: interactions.executorId, capabilities: { ...capabilities }, pendingApprovals: interactions.snapshot() }; }
+  function snapshot() { return { ...state, executorId: interactions.executorId, capabilities: { ...capabilities },
+    account: account.snapshot(), pendingApprovals: interactions.snapshot() }; }
+
+  async function readAccount() { requireOpen(); await account.refresh(); requireOpen(); return account.snapshot(); }
 
-  return { capabilities, open, send, interrupt, close, snapshot, respond: interactions.respond };
+  return { capabilities, open, send, interrupt, close, snapshot, readAccount, respond: interactions.respond };
 }

package/lib/integrations/native/dsh-acp.mjs

@@ -2,6 +2,8 @@ import path from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { createNativeInteractions } from './interactions.mjs';
 import { JsonRpcProcess } from './jsonrpc.mjs';
+import { acpUsage } from './telemetry.mjs';
+import { captureSelectedCwdIdentity } from '../../process/selected-cwd-identity.mjs';
 
 export const DSH_ACP_BASELINE_VERSION = '0.2.0-rc.2';
 
@@ -16,6 +18,7 @@ export const DSH_ACP_BASELINE_VERSION = '0.2.0-rc.2';
 export function createDshAcpAdapter(options = {}) {
   const cwd = options.cwd || process.cwd();
   if (!path.isAbsolute(cwd)) throw failure('NATIVE_BAD_CWD', 'ACP requires an absolute workspace directory');
+  const cwdBinding = captureSelectedCwdIdentity(cwd, options.expectedCwdIdentity);
   const capabilities = {
     create: true, resume: false, send: true, observe: true,
     steer: false, interrupt: true, close: false, fork: false, approvals: Boolean(options.interactive), mcp: Boolean(options.mcpServers)
@@ -26,9 +29,13 @@ export function createDshAcpAdapter(options = {}) {
   let active = null;
   let opening = null;
   let openingIdentity = null;
-  let closing = null;
+  let closing = false;
+  let closePromise = null;
+  let runtimeDisposalStarted = false;
+  let runtimeExited = false;
   let runtimeDisposed = false;
   let lastError = null;
+  let metrics = null, runtimeMetadata = {};
   const receipts = new Map();
   const toolCalls = new Map(), toolContextWaiters = new Set();
   const interactions = createNativeInteractions({ executorId: options.executorId,
@@ -50,6 +57,7 @@ export function createDshAcpAdapter(options = {}) {
       cwd, sessionId, status,
       turnId: active?.turnId || null,
       submissionId: active?.submissionId || null,
+      metrics, runtimeMetadata: { ...runtimeMetadata },
       capabilities: { ...capabilities }, executorId: interactions.executorId, pendingApprovals: interactions.snapshot(),
       error: lastError ? { ...lastError } : null
     };
@@ -89,6 +97,12 @@ export function createDshAcpAdapter(options = {}) {
     if (closing || ['closed', 'failed', 'exited'].includes(status) || method !== 'session/update' || params?.sessionId !== sessionId) return;
     const update = params.update;
     if (!update || typeof update !== 'object') return;
+    const reported = acpUsage(update);
+    if (reported) { metrics = reported; emit({ type: 'usage', metrics, turnId: active?.turnId || null }); }
+    if (update.sessionUpdate === 'available_commands_update' && Array.isArray(update.availableCommands)) {
+      runtimeMetadata = { ...runtimeMetadata, commands: update.availableCommands.filter(command => typeof command?.name === 'string').map(command => ({ name: command.name, description: command.description })) };
+      emit({ type: 'metadata', runtimeMetadata: { ...runtimeMetadata } });
+    }
     rememberToolCall(update);
     if (update.sessionUpdate === 'agent_message_chunk' && update.content?.type === 'text' && typeof update.content.text === 'string') {
       if (active) active.text += update.content.text;
@@ -135,6 +149,8 @@ export function createDshAcpAdapter(options = {}) {
   }
 
   function onExit(info) {
+    runtimeExited = true;
+    cwdBinding.release();
     if (closing || runtimeDisposed || status === 'closed') return;
     const turn = active;
     interactions.expire();
@@ -176,6 +192,7 @@ export function createDshAcpAdapter(options = {}) {
     openingIdentity = input.sessionId || null;
     opening = (async () => {
       try {
+        cwdBinding.assertUnchanged();
         const config = {
           binary: options.binary || 'dsh', args: ['--profile', 'acp'],
           cwd, env: options.env, timeoutMs: options.timeoutMs,
@@ -193,6 +210,7 @@ export function createDshAcpAdapter(options = {}) {
         capabilities.resume = extensions.resume !== undefined && extensions.resume !== null && extensions.resume !== false;
         capabilities.close = extensions.close !== undefined && extensions.close !== null && extensions.close !== false;
         if (input.sessionId && !capabilities.resume) throw failure('NATIVE_UNSUPPORTED', 'This ACP runtime does not advertise session resume');
+        cwdBinding.assertUnchanged();
         const result = await rpc.request(input.sessionId ? 'session/resume' : 'session/new', {
           ...(input.sessionId ? { sessionId: input.sessionId } : {}),
           cwd, mcpServers: Object.entries(options.mcpServers || {}).map(([name, config]) => ({ name, command: config.command, args: config.args,
@@ -203,13 +221,18 @@ export function createDshAcpAdapter(options = {}) {
           throw failure('NATIVE_PROTOCOL_ERROR', 'ACP returned an invalid session identity');
         }
         sessionId = resolvedId;
+        const reportedModel = result?.configOptions?.find(option => option?.id === 'model')?.currentValue || result?.models?.currentModelId;
+        runtimeMetadata = typeof reportedModel === 'string' ? { model: reportedModel } : {};
         if (input.model !== undefined) {
           const model = result?.configOptions?.find((option) => option?.id === 'model');
           if (!model || !advertisesValue(model.options, input.model)) throw failure('NATIVE_UNSUPPORTED_MODEL', 'Model must match an advertised ACP model option value');
-          await rpc.request('session/set_config_option', { sessionId, configId: 'model', value: input.model });
+          const configured = await rpc.request('session/set_config_option', { sessionId, configId: 'model', value: input.model });
+          const confirmed = configured?.configOptions?.find(option => option?.id === 'model')?.currentValue;
+          runtimeMetadata = typeof confirmed === 'string' ? { model: confirmed } : {};
         }
         if (closing || status === 'exited') throw failure('NATIVE_ADAPTER_CLOSED', 'The dsh ACP runtime closed during session initialization');
         status = 'idle';
+        emit({ type: 'metadata', runtimeMetadata: { ...runtimeMetadata } });
         emit({ type: 'opened', resumed: Boolean(input.sessionId), status });
         return snapshot();
       } catch (error) {
@@ -239,6 +262,7 @@ export function createDshAcpAdapter(options = {}) {
     }
     if (input.expectedTurnId && input.expectedTurnId !== active?.turnId) throw failure('NATIVE_STALE_TURN', 'The expected ACP submission is no longer active');
     if (active) throw failure('NATIVE_BUSY', 'ACP permits one in-flight prompt per session and does not support steering');
+    cwdBinding.assertUnchanged();
     clearToolContext();
     const turn = { turnId: randomUUID(), submissionId, text: '' };
     active = turn;
@@ -252,11 +276,12 @@ export function createDshAcpAdapter(options = {}) {
     // only the real RPC response constitutes a completed submission.
     void Promise.resolve().then(() => {
       if (closing) throw failure('NATIVE_ADAPTER_CLOSED', 'The adapter closed before prompt submission');
+      cwdBinding.assertUnchanged();
       return rpc.request('session/prompt', {
         sessionId, prompt: [{ type: 'text', text: input.text }]
       }, { timeoutMs: 0 });
     }).then((result) => {
-      if (active !== turn) return;
+      if (active !== turn || closing) return;
       if (!['end_turn', 'max_tokens', 'max_turn_requests', 'refusal', 'cancelled'].includes(result?.stopReason)) {
         throw failure('NATIVE_PROTOCOL_ERROR', 'ACP prompt returned an invalid stop reason');
       }
@@ -267,7 +292,7 @@ export function createDshAcpAdapter(options = {}) {
       emit({ type: 'completed', status: result.stopReason === 'cancelled' ? 'interrupted' : 'completed',
         sessionId, turnId: turn.turnId, submissionId, text: turn.text, stopReason: result.stopReason });
     }).catch((error) => {
-      if (active !== turn) return;
+      if (active !== turn || closing) return;
       interactions.expire(turn.turnId);
       clearToolContext();
       active = null;
@@ -300,30 +325,48 @@ export function createDshAcpAdapter(options = {}) {
   }
 
   function close() {
-    if (closing) return closing;
-    closing = (async () => {
-      status = 'closing';
-      interactions.expire();
-      clearToolContext();
-      const errors = [];
-      if (opening) { try { await opening; } catch {} }
-      if (rpc && !runtimeDisposed && sessionId && capabilities.close) {
-        try { await rpc.request('session/close', { sessionId }); } catch (error) { errors.push(error); }
-      }
-      try { await disposeRuntime(); } catch (error) { errors.push(error); }
-      active = null;
-      status = 'closed';
-      emit({ type: 'closed', status });
-      if (errors.length) throw new AggregateError(errors, 'ACP session or owned runtime cleanup failed');
-      return snapshot();
+    if (closePromise) return closePromise;
+    if (runtimeDisposed && status === 'closed') return Promise.resolve(snapshot());
+    // Once closure is requested, failed cleanup must never reopen this worker.
+    // Only the in-flight cleanup promise is retryable.
+    closing = true;
+    const operation = (async () => {
+      try {
+        status = 'closing';
+        interactions.expire();
+        clearToolContext();
+        const errors = [];
+        if (opening) { try { await opening; } catch {} }
+        if (rpc && !runtimeDisposed && !runtimeExited && !runtimeDisposalStarted && sessionId && capabilities.close) {
+          try { await rpc.request('session/close', { sessionId }); } catch (error) { errors.push(error); }
+        }
+        try { await disposeRuntime(); } catch (error) { errors.push(error); }
+        if (errors.length) lastError = { ...describe(errors.at(-1)), ...(!runtimeDisposed ? { uncertain: true } : {}) };
+        status = runtimeDisposed ? 'closed' : 'failed';
+        if (runtimeDisposed) {
+          active = null;
+          emit({ type: 'closed', status });
+        }
+        if (errors.length) throw new AggregateError(errors, 'ACP session or owned runtime cleanup failed');
+        return snapshot();
+      } finally { cwdBinding.release(); }
     })();
-    return closing;
+    closePromise = operation;
+    void operation.catch(() => { if (closePromise === operation) closePromise = null; });
+    return operation;
   }
 
   async function disposeRuntime() {
-    if (runtimeDisposed) return;
-    runtimeDisposed = true;
-    await rpc?.close();
+    if (runtimeDisposed || runtimeExited) { runtimeDisposed = true; return; }
+    runtimeDisposalStarted = true;
+    try {
+      await rpc?.close();
+      runtimeDisposed = true;
+    } finally {
+      // The transport may report its own cleanup failure after observing exit.
+      // Preserve that error while retaining the independent exit receipt.
+      if (runtimeExited) runtimeDisposed = true;
+    }
   }
 
   return { capabilities, open, send, interrupt, close, snapshot, respond: interactions.respond };

package/lib/integrations/native/index.mjs

@@ -1,4 +1,5 @@
 import { CliError } from '../../shared/errors.mjs';
+import { HOOK_ROOT_IDENTITY_ENV, hookRootIdentityValue } from '../../core/sessions/hook-root-identity.mjs';
 
 export const NATIVE_PROVIDERS = Object.freeze(['codex', 'claude', 'dsh']);
 
@@ -15,5 +16,7 @@ export function nativeWorkerEnv(env, ctx, peer, owner) {
     !['CODEX_THREAD_ID', 'CODEX_SESSION_ID', 'CLAUDE_SESSION_ID', 'CLAUDECODE'].includes(key)));
   // Explicit, worker-specific coordination identity; provider credentials and
   // the real HOME are preserved. No global configuration is rewritten.
-  return { ...clean, HCC_ROOT: ctx.root, HCC_DB: ctx.dbPath, HCC_PEER: peer, ...(owner ? { HCC_NATIVE_OWNER: owner } : {}) };
+  return { ...clean, HCC_ROOT: ctx.root, HCC_DB: ctx.dbPath, HCC_PEER: peer,
+    [HOOK_ROOT_IDENTITY_ENV]: hookRootIdentityValue(ctx.root, ctx.initialRootIdentity || ctx.rootIdentity),
+    ...(owner ? { HCC_NATIVE_OWNER: owner } : {}) };
 }

package/lib/integrations/native/interactions.mjs

@@ -1,4 +1,5 @@
 import { randomUUID } from 'node:crypto';
+import { redactMcpUrlInteraction } from '../mcp-url-elicitation.mjs';
 
 // Only the owning runtime can answer. Answers, including secrets, are never
 // placed in snapshots, events or persistent delivery receipts.
@@ -33,7 +34,7 @@ export function createNativeInteractions({ executorId = randomUUID(), isActive,
         signal.addEventListener('abort', aborted, { once: true });
         entry.cleanup = () => signal.removeEventListener('abort', aborted);
       }
-      onChange?.({ type: 'approval', ...snapshot().find(value => value.requestId === id) });
+      onChange?.(redactMcpUrlInteraction({ type: 'approval', ...snapshot().find(value => value.requestId === id) }));
     });
     return promise;
   }

package/lib/integrations/native/jsonrpc.mjs

@@ -1,5 +1,28 @@
-import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
 import { CliError } from '../../shared/errors.mjs';
+import { spawnPinnedCwdProcess } from '../../process/pinned-cwd.mjs';
+
+function assertExecutableAvailable(binary, cwd, env) {
+  const searchPath = env === undefined ? process.env.PATH : env.PATH;
+  const candidates = binary.includes('/')
+    ? [path.resolve(cwd, binary)]
+    : String(searchPath === undefined ? '/usr/bin:/bin' : searchPath)
+      .split(path.delimiter).map(entry => path.resolve(cwd, entry || '.', binary));
+  let inaccessible = false;
+  for (const candidate of candidates) {
+    try {
+      fs.accessSync(candidate, fs.constants.X_OK);
+      if (fs.statSync(candidate).isFile()) return;
+    } catch (error) {
+      if (error?.code === 'EACCES') inaccessible = true;
+    }
+  }
+  const code = inaccessible ? 'EACCES' : 'ENOENT';
+  throw Object.assign(new Error('Cannot start ' + binary + ': ' + code), {
+    code, path: binary, syscall: 'spawn'
+  });
+}
 
 // Each transport owns the child it starts. It never connects to a desktop
 // application's private server or signals a process supplied by the caller.
@@ -18,7 +41,10 @@ export class JsonRpcProcess {
   async start() {
     if (this.child || this.closed) throw new CliError('NATIVE_TRANSPORT_STATE', 'Transport cannot be started twice');
     const { binary, args = [], cwd, env } = this.options;
-    this.child = spawn(binary, args, { cwd, env, shell: false, stdio: ['pipe', 'pipe', 'pipe'] });
+    assertExecutableAvailable(binary, cwd || process.cwd(), env);
+    this.child = spawnPinnedCwdProcess(binary, args, {
+      cwd: cwd || process.cwd(), env, shell: false, stdio: ['pipe', 'pipe', 'pipe']
+    });
     this.child.stdout.setEncoding('utf8');
     this.child.stdout.on('data', (chunk) => this.read(chunk));
     // Drain stderr without putting credentials or unbounded provider logs into
@@ -86,8 +112,8 @@ export class JsonRpcProcess {
     const error = new CliError('NATIVE_PROTOCOL_ERROR', message, { uncertain: true });
     this.fail(error);
     this.reportError(error);
-    // Retain a rejected closePromise for explicit callers without making an
-    // asynchronous protocol failure produce an unhandled rejection.
+    // Report failed cleanup without an unhandled rejection. Explicit callers
+    // may retry termination; the original attempt keeps its failure receipt.
     void this.close().catch((closeError) => {
       this.lastCloseError = closeError;
       this.reportError(closeError);
@@ -180,6 +206,12 @@ export class JsonRpcProcess {
       try { child.stdin.end(); } catch {}
       signal('SIGTERM');
     });
-    return this.closePromise;
+    const closing = this.closePromise;
+    void closing.catch(() => {
+      // Share a pending attempt, but do not pin a transient signal/exit failure
+      // forever. A retry must still confirm this owned child's actual exit.
+      if (this.closePromise === closing) this.closePromise = null;
+    });
+    return closing;
   }
 }

package/lib/integrations/native/telemetry.mjs

@@ -0,0 +1,30 @@
+// Preserve only counters actually reported by the upstream protocol. No token
+// estimates, local duration substitutes, or cumulative-usage/context inference.
+function fields(source, mapping) {
+  const result = {};
+  for (const [key, field] of Object.entries(mapping)) {
+    const value = source?.[field];
+    if (typeof value === 'number' && Number.isFinite(value) && value >= 0) result[key] = value;
+  }
+  return result;
+}
+
+export function codexUsage(params, observedAt = Date.now()) {
+  const usage = params?.tokenUsage;
+  if (!usage || typeof usage !== 'object') return null;
+  const counters = fields(usage.total, { inputTokens: 'inputTokens', outputTokens: 'outputTokens', cachedInputTokens: 'cachedInputTokens', totalTokens: 'totalTokens' });
+  Object.assign(counters, fields(usage, { contextWindow: 'modelContextWindow' }));
+  return Object.keys(counters).length ? { source: 'codex thread/tokenUsage/updated', scope: 'session', ...(params.turnId ? { turnId: params.turnId } : {}), observedAt, ...counters } : null;
+}
+
+export function claudeUsage(message, turnId, observedAt = Date.now()) {
+  const counters = { ...fields(message?.usage, { inputTokens: 'input_tokens', outputTokens: 'output_tokens', cachedInputTokens: 'cache_read_input_tokens', totalTokens: 'total_tokens' }),
+    ...fields(message, { durationMs: 'duration_ms' }) };
+  return Object.keys(counters).length ? { source: 'claude SDK result', scope: 'turn', ...(turnId ? { turnId } : {}), observedAt, ...counters } : null;
+}
+
+export function acpUsage(update, observedAt = Date.now()) {
+  if (update?.sessionUpdate !== 'usage_update') return null;
+  const counters = fields(update, { contextTokens: 'used', contextWindow: 'size' });
+  return Object.keys(counters).length ? { source: 'ACP session/update usage_update', scope: 'session', observedAt, ...counters } : null;
+}

package/lib/process/identity.mjs

@@ -97,6 +97,10 @@ function macTokenFormat(token) {
   if (legacy && BigInt(legacy[1]) > 0n && Number(legacy[2]) >= 0 && Number(legacy[2]) <= 999999) return 'legacy-wall-clock';
   const current = /^darwin:([^:]+):(.+)$/.exec(token);
   if (current && MAC_BOOT_UUID.test(current[1]) && new RegExp(`^${start}$`).test(current[2])) return 'boot-session';
+  // Earlier workbench candidates used a different prefix for the same OS
+  // evidence. A prefix change alone must not prove that their owner exited.
+  const preview = /^mac:([^:]+):(.+)$/.exec(token);
+  if (preview && MAC_BOOT_UUID.test(preview[1]) && new RegExp(`^${start}$`).test(preview[2])) return 'preview-boot-session';
   return null;
 }