@logicseek/hello-cc 1.1.0 → 1.1.1

package/scripts/regression.mjs

@@ -57,6 +57,7 @@ const fixtureFailures = new WeakSet();
 const fixtureCommandFailures = new WeakMap();
 const fixtureHttpFailures = new WeakMap();
 const fixtureShimRegistrationFailures = new WeakMap();
+const fixtureTmuxGcFailures = new WeakMap();
 const managedTmuxSessions = new Set();
 
 const env = {
@@ -102,6 +103,9 @@ export function fixtureFailureError(message, commandResult = null, diagnosticOpe
   if (diagnosticOperation === 'shim-registration') {
     fixtureShimRegistrationFailures.set(error, fixtureShimRegistrationSummary(commandResult));
   }
+  if (diagnosticOperation === 'tmux-gc') {
+    fixtureTmuxGcFailures.set(error, fixtureTmuxGcSummary(commandResult));
+  }
   return error;
 }
 
@@ -117,10 +121,32 @@ export function fixtureFailureDiagnostic(error) {
     ...(fixtureHttpFailures.has(error) ? { http: fixtureHttpFailures.get(error) } : {}),
     ...(fixtureShimRegistrationFailures.has(error)
       ? { shimRegistration: fixtureShimRegistrationFailures.get(error) } : {}),
+    ...(fixtureTmuxGcFailures.has(error) ? { tmuxGc: fixtureTmuxGcFailures.get(error) } : {}),
     ...(terminalMarker ? { terminalMarker } : {})
   };
 }
 
+export function fixtureTmuxGcSummary(observation = {}) {
+  const reasons = ['stale_hcc_managed_session', 'stale_rebind_cleanup_failed_session',
+    'tmux_stored_evidence_incomplete', 'tmux_session_changed', 'tmux_session_reused',
+    'tmux_session_id_changed', 'tmux_root_unknown', 'tmux_root_changed', 'tmux_pane_changed',
+    'tmux_pane_not_dead', 'tmux_dead_process_pid_unknown', 'tmux_dead_process_pid_changed', 'tmux_process_not_confirmed_dead',
+    'tmux_process_changed', 'tmux_clients_unknown', 'tmux_has_clients',
+    'tmux_binding_subject_incomplete', 'tmux_binding_session_authority_changed',
+    'tmux_binding_root_authority_changed', 'tmux_binding_pane_authority_changed',
+    'tmux_owner_process_live', 'tmux_owner_process_incompatible', 'tmux_target_missing',
+    'not_hcc_managed_name', 'hcc_root_mismatch', 'duplicate_db_binding', 'runtime_managed',
+    'not_old_enough', 'old_runtime_target_changed'];
+  return Object.freeze(Object.fromEntries(['stale', 'peerFilter', 'deadBinding', 'deadEvent'].map(role => {
+    const value = observation?.[role];
+    return [role, Object.freeze({
+      candidate: typeof value?.candidate === 'boolean' ? value.candidate : null,
+      reason: reasons.includes(value?.reason) ? value.reason : 'unknown',
+      mode: ['dead_process', 'explicit_exit_live'].includes(value?.mode) ? value.mode : null
+    })];
+  })));
+}
+
 export function fixtureShimRegistrationSummary(observation = {}) {
   // Public annotations retain only fixture-owned booleans and finite enums.
   // CLI tables, provider output, identifiers, paths and environment are excluded.
@@ -983,6 +1009,17 @@ async function assertTmuxGcPolicy() {
   await waitFor(() => run('tmux', ['display-message', '-p', '-t', deadEventPane, '#{pane_dead}']).trim() === '1', 'dead event pane');
   await waitFor(() => run('tmux', ['display-message', '-p', '-t', clientUnknownEventPane, '#{pane_dead}']).trim() === '1', 'client-unknown dead event pane');
   await waitFor(() => run('tmux', ['display-message', '-p', '-t', deadBindingPane, '#{pane_dead}']).trim() === '1', 'dead binding pane');
+  // Recent tmux hides pane_pid after PTY closure. Keep the destructive guard
+  // strict: test deletion only when this host still supplies the original PID,
+  // and require an explicit safe skip otherwise. Never substitute a saved PID.
+  const retainsDeadPanePid = (pane, evidence) => {
+    const pid = Number(run('tmux', ['display-message', '-p', '-t', pane, '#{pane_pid}']).trim());
+    if (!Number.isSafeInteger(pid) || pid <= 0) return false;
+    if (pid !== evidence.old_process_identity.pid) fail('dead tmux fixture process changed before GC');
+    return true;
+  };
+  const deadBindingGcAvailable = retainsDeadPanePid(deadBindingPane, deadBindingEvidence);
+  const deadEventGcAvailable = retainsDeadPanePid(deadEventPane, deadEventEvidence);
 
   const attachTmux = realTmuxBin ? `${sh(realTmuxBin)} -L ${sh(tmuxSocketName)}` : 'tmux';
   const client = spawnSync('tmux', ['new-session', '-d', '-s', `${tmuxSession}-gc-client`, '-e', `HCC_ROOT=${root}`, 'sh', '-lc', `unset TMUX; exec ${attachTmux} attach-session -t ${sh(attachedSession)}`], {
@@ -1000,21 +1037,35 @@ async function assertTmuxGcPolicy() {
       HCC_REGRESSION_TMUX_FAIL_CLIENT_SESSIONS: [clientUnknownEventSession, clientUnknownBindingSession].join(' ')
     };
     const dryRun = hcc(['tmux', 'gc', '--older-than', '14'], { env: gcEnv });
+    const dryRunJson = hccJson(['tmux', 'gc', '--older-than', '14'], { env: gcEnv });
+    const gcObservation = Object.fromEntries(Object.entries({
+      stale: stalePeer, peerFilter: peerFilterPeer, deadBinding: deadBindingPeer, deadEvent: deadEventPeer
+    }).map(([role, peer]) => {
+      const candidate = dryRunJson.candidates.find(row => row.peer === peer);
+      const row = candidate || dryRunJson.skipped.find(row => row.peer === peer);
+      return [role, { candidate: Boolean(candidate), reason: row?.reason, mode: row?.gc_validation_mode }];
+    }));
     if (!gcOutputHasPeer(dryRun, stalePeer) || !dryRun.includes('stale_hcc_managed_session') ||
         !gcOutputHasPeer(dryRun, peerFilterPeer) ||
-        !gcOutputHasPeer(dryRun, deadBindingPeer) ||
-        !gcOutputHasPeer(dryRun, deadEventPeer) || !dryRun.includes('stale_rebind_cleanup_failed_session')) {
-      fail(`tmux gc dry-run did not list stale DB-proven managed session:\n${dryRun}`);
+        gcOutputHasPeer(dryRun, deadBindingPeer) !== deadBindingGcAvailable ||
+        gcOutputHasPeer(dryRun, deadEventPeer) !== deadEventGcAvailable ||
+        (deadEventGcAvailable && !dryRun.includes('stale_rebind_cleanup_failed_session'))) {
+      fail(`tmux gc dry-run did not list stale DB-proven managed session:\n${dryRun}\n${JSON.stringify(gcObservation)}`,
+        gcObservation, 'tmux-gc');
+    }
+    for (const [peer, available] of [[deadBindingPeer, deadBindingGcAvailable], [deadEventPeer, deadEventGcAvailable]]) {
+      if (!available && !dryRunJson.skipped.some(row => row.peer === peer && row.reason === 'tmux_dead_process_pid_unknown')) {
+        fail('tmux gc must retain dead panes whose process binding is unavailable', gcObservation, 'tmux-gc');
+      }
     }
     for (const protectedPeer of [reusedBindingPeer, clientUnknownBindingPeer, eventPeer, reusedEventPeer, reusedProcessEventPeer, clientUnknownEventPeer, rootEventPeer, legacyEventPeer]) {
       if (gcOutputHasPeer(dryRun, protectedPeer)) {
         fail(`tmux gc dry-run treated live/unknown event evidence as removable (${protectedPeer}):\n${dryRun}`);
       }
     }
-    const dryRunJson = hccJson(['tmux', 'gc', '--older-than', '14'], { env: gcEnv });
     const candidateModes = new Map(dryRunJson.candidates.map((candidate) => [candidate.peer, candidate.gc_validation_mode]));
     if (candidateModes.get(stalePeer) !== 'explicit_exit_live' ||
-        candidateModes.get(deadBindingPeer) !== 'dead_process') {
+        candidateModes.get(deadBindingPeer) !== (deadBindingGcAvailable ? 'dead_process' : undefined)) {
       fail(`tmux gc did not record strict binding validation modes:\n${JSON.stringify(dryRunJson.candidates, null, 2)}`);
     }
     if (runMaybe('tmux', ['has-session', '-t', staleSession]).status !== 0) {
@@ -1037,7 +1088,9 @@ async function assertTmuxGcPolicy() {
     }
 
     const removed = hcc(['tmux', 'gc', '--older-than', '14', '--yes'], { env: gcEnv });
-    if (!gcOutputHasPeer(removed, stalePeer) || !gcOutputHasPeer(removed, deadBindingPeer) || !gcOutputHasPeer(removed, deadEventPeer) ||
+    if (!gcOutputHasPeer(removed, stalePeer) ||
+        gcOutputHasPeer(removed, deadBindingPeer) !== deadBindingGcAvailable ||
+        gcOutputHasPeer(removed, deadEventPeer) !== deadEventGcAvailable ||
         gcOutputHasPeer(removed, reusedBindingPeer) || gcOutputHasPeer(removed, clientUnknownBindingPeer) ||
         gcOutputHasPeer(removed, eventPeer) || gcOutputHasPeer(removed, reusedEventPeer) ||
         gcOutputHasPeer(removed, reusedProcessEventPeer) || gcOutputHasPeer(removed, clientUnknownEventPeer) ||
@@ -1048,11 +1101,11 @@ async function assertTmuxGcPolicy() {
     if (runMaybe('tmux', ['has-session', '-t', staleSession]).status === 0) {
       fail('tmux gc --yes did not delete stale DB-proven managed session');
     }
-    if (runMaybe('tmux', ['has-session', '-t', deadBindingSession]).status === 0) {
-      fail('tmux gc --yes did not delete a truly dead exact binding session');
+    if ((runMaybe('tmux', ['has-session', '-t', deadBindingSession]).status !== 0) !== deadBindingGcAvailable) {
+      fail('tmux gc --yes must delete only a truly dead exact binding session with its original PID');
     }
-    if (runMaybe('tmux', ['has-session', '-t', deadEventSession]).status === 0) {
-      fail('tmux gc --yes did not delete a confirmed-dead rebind cleanup session listed by dry-run');
+    if ((runMaybe('tmux', ['has-session', '-t', deadEventSession]).status !== 0) !== deadEventGcAvailable) {
+      fail('tmux gc --yes must retain rebind cleanup sessions lacking a confirmed process binding');
     }
     for (const protectedSession of [reusedBindingSession, clientUnknownBindingSession, eventSession, reusedEventSession, reusedProcessEventSession, clientUnknownEventSession, rootEventSession, manualSession]) {
       if (runMaybe('tmux', ['has-session', '-t', protectedSession]).status !== 0) {
@@ -1087,7 +1140,8 @@ async function assertTmuxGcPolicy() {
       fail(`tmux gc changed attached-client binding:\n${JSON.stringify(attachedBinding, null, 2)}`);
     }
     const deadBinding = peerBindingRow(deadBindingPeer);
-    if (!deadBinding || deadBinding.transport !== 'detached' || deadBinding.runtime_target !== null) {
+    if (!deadBinding || deadBinding.transport !== (deadBindingGcAvailable ? 'detached' : 'tmux') ||
+        deadBinding.runtime_target !== (deadBindingGcAvailable ? null : deadBindingPane)) {
       fail(`tmux gc did not detach truly dead binding:\n${JSON.stringify(deadBinding, null, 2)}`);
     }
     for (const [peer, pane] of [

package/scripts/web-native-retry-checks.mjs

@@ -5,6 +5,21 @@ import { DatabaseSync } from 'node:sqlite';
 
 const FAILURE_CODE = 'NATIVE_ACCEPTANCE_COMMIT_GAP';
 const hash = text => createHash('sha256').update(text).digest('hex');
+
+// Retain enough to distinguish a conflict from a lost response without
+// writing response text, drafts, authorization headers or action tokens.
+export function summarizeNativeRetryResponse(status, body) {
+  const bytes = Buffer.from(body);
+  const summary = { status, bytes: bytes.length, bodySha256: hash(bytes), format: 'non-json', code: null };
+  if (bytes.length <= 65536) {
+    try {
+      const value = JSON.parse(bytes.toString('utf8'));
+      summary.format = 'json';
+      if (typeof value?.error?.code === 'string' && /^[A-Z][A-Z0-9_]{0,79}$/.test(value.error.code)) summary.code = value.error.code;
+    } catch { /* The hash still identifies an HTML, empty or malformed response. */ }
+  } else summary.format = 'oversized';
+  return summary;
+}
 function readMesh(dbPath, read) {
   const db = new DatabaseSync(dbPath, { readOnly: true });
   try { return read(db); } finally { db.close(); }
@@ -62,12 +77,17 @@ export async function runNativeRetryChecks({ browser, base, token, root, dbPath,
     const context = await browser.newContext({ viewport: { width: 1440, height: 1000 } });
     await context.addInitScript(browserInstrumentation);
     const page = await context.newPage(); watch(page);
-    const requests = [], responses = [];
+    const requests = [], responses = [], responseDetails = [], responseReads = [];
     page.on('request', request => {
       if (request.method() === 'POST' && new URL(request.url()).pathname === route) requests.push(request.postDataJSON());
     });
     page.on('response', response => {
-      if (response.request().method() === 'POST' && new URL(response.url()).pathname === route) responses.push(response.status());
+      if (response.request().method() !== 'POST' || new URL(response.url()).pathname !== route) return;
+      responses.push(response.status());
+      const summary = { status: response.status(), format: 'unavailable', code: null };
+      responseDetails.push(summary);
+      responseReads.push(response.body().then(body => Object.assign(summary, summarizeNativeRetryResponse(response.status(), body)))
+        .catch(() => { summary.format = 'unavailable'; }));
     });
     let observerContext, workerStarted = false, failure;
     try {
@@ -147,17 +167,21 @@ export async function runNativeRetryChecks({ browser, base, token, root, dbPath,
       await shot(page, viewport.name + '-native-retry-reconciled');
       assert.equal(await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth + 2), true);
       assert.deepEqual(responses, [409, 200]);
+      await Promise.all(responseReads);
+      assert.equal(responseDetails[0].code, FAILURE_CODE);
+      assert.equal(responseDetails[1].format, 'json');
       receipt.scenarios.push({ viewport, peer, submissionId, messageId: message.message_id,
         owner: originalState.owner, generation: originalState.generation,
-        requestCount: requests.length, responseStatuses: responses, expectedFailure: FAILURE_CODE,
+        requestCount: requests.length, responseStatuses: responses, responseDetails, expectedFailure: FAILURE_CODE,
         originalBodySha256: hash(original), laterDraftPreserved: true, observerRetryBlocked: true,
         messages: counts.messages, durableIntents: counts.intents, pendingEvents: counts.pendingEvents,
         deliveries: active.deliveries.length, userOriginRetained: true, providerInputs: adapter.sent });
       check('native retry ' + viewport.name + ': original durable submission repairs once; edited draft and observer fence survive');
     } catch (error) {
       failure = error;
+      await Promise.all(responseReads);
       receipt.failure = { viewport: viewport.name, peer, message: error.message, requestCount: requests.length,
-        responseStatuses: responses, injected: retryFault.injected.filter(value => value.peer === peer) };
+        responseStatuses: responses, responseDetails, injected: retryFault.injected.filter(value => value.peer === peer) };
       try { await shot(page, viewport.name + '-native-retry-failure'); } catch { /* Preserve the original assertion. */ }
       throw error;
     } finally {