polygram 0.22.0 → 0.23.1

package/lib/db/codex-retention.js

@@ -0,0 +1,139 @@
+'use strict';
+
+const DAY_MS = 86_400_000;
+const SETTLED_RETENTION_MS = 30 * DAY_MS;
+const AMBIGUOUS_RETENTION_MS = 90 * DAY_MS;
+
+function pruneCodexOperationalData(rawDb, {
+  now = Date.now(),
+  settledRetentionMs = SETTLED_RETENTION_MS,
+  ambiguousRetentionMs = AMBIGUOUS_RETENTION_MS,
+} = {}) {
+  for (const [value, label] of [
+    [now, 'now'],
+    [settledRetentionMs, 'settledRetentionMs'],
+    [ambiguousRetentionMs, 'ambiguousRetentionMs'],
+  ]) {
+    if (!Number.isSafeInteger(value) || value < 0) {
+      throw new TypeError(`Codex retention ${label} must be a non-negative integer`);
+    }
+  }
+  if (ambiguousRetentionMs < settledRetentionMs) {
+    throw new TypeError(
+      'Codex ambiguous retention cannot be shorter than settled retention',
+    );
+  }
+
+  return rawDb.transaction(() => {
+    const settledCutoff = now - settledRetentionMs;
+    const ambiguousCutoff = now - ambiguousRetentionMs;
+    const attempts = rawDb.prepare(`
+      DELETE FROM codex_turn_attempts
+       WHERE (
+         (
+           recovery_state = 'settled'
+           AND settled_ts IS NOT NULL
+           AND settled_ts < @settledCutoff
+         )
+         OR
+         (
+           recovery_state = 'ambiguous'
+           AND ambiguous_ts IS NOT NULL
+           AND ambiguous_ts < @ambiguousCutoff
+           AND EXISTS (
+             SELECT 1
+               FROM codex_attempt_reconciliations r
+              WHERE r.attempt_id = codex_turn_attempts.attempt_id
+           )
+         )
+       )
+       AND NOT EXISTS (
+         SELECT 1
+           FROM codex_daemon_lease lease
+          WHERE lease.generation_id = codex_turn_attempts.generation_id
+            AND lease.status IN ('active', 'quarantined')
+       )
+       AND NOT EXISTS (
+         SELECT 1
+           FROM codex_linked_inputs linked
+          WHERE (
+            linked.attempt_id = codex_turn_attempts.attempt_id
+            OR linked.target_attempt_id = codex_turn_attempts.attempt_id
+          )
+            AND linked.state = 'linked'
+       )
+       AND NOT EXISTS (
+         SELECT 1
+           FROM codex_retry_reservations retry
+          WHERE (
+            retry.original_attempt_id = codex_turn_attempts.attempt_id
+            OR retry.retry_attempt_id = codex_turn_attempts.attempt_id
+          )
+            AND retry.state != 'retired'
+       )
+       AND NOT EXISTS (
+         SELECT 1
+           FROM codex_generations generation
+          WHERE generation.generation_id = codex_turn_attempts.generation_id
+            AND generation.state = 'containment-failed'
+            AND NOT EXISTS (
+              SELECT 1
+                FROM codex_reboot_releases release
+               WHERE release.stable_host_id = generation.stable_host_id
+                 AND release.incident_boot_session_id =
+                     generation.boot_session_id
+            )
+       )
+    `).run({ settledCutoff, ambiguousCutoff });
+
+    const generations = rawDb.prepare(`
+      DELETE FROM codex_generations
+       WHERE (
+           (
+             state IN ('healthy-stopped', 'retired')
+             AND settled_ts IS NOT NULL
+             AND settled_ts < @settledCutoff
+           )
+           OR
+           (
+             state = 'created'
+             AND updated_ts < @ambiguousCutoff
+           )
+           OR
+           (
+             state = 'containment-failed'
+             AND updated_ts < @ambiguousCutoff
+             AND EXISTS (
+               SELECT 1
+                 FROM codex_reboot_releases release
+                WHERE release.stable_host_id = codex_generations.stable_host_id
+                  AND release.incident_boot_session_id =
+                      codex_generations.boot_session_id
+             )
+           )
+         )
+         AND NOT EXISTS (
+           SELECT 1
+             FROM codex_turn_attempts attempt
+            WHERE attempt.generation_id = codex_generations.generation_id
+         )
+         AND NOT EXISTS (
+           SELECT 1
+             FROM codex_daemon_lease lease
+            WHERE lease.generation_id = codex_generations.generation_id
+              AND lease.status IN ('active', 'quarantined')
+         )
+    `).run({ settledCutoff, ambiguousCutoff });
+    return {
+      deletedAttempts: attempts.changes,
+      deletedGenerations: generations.changes,
+    };
+  })();
+}
+
+module.exports = {
+  DAY_MS,
+  SETTLED_RETENTION_MS,
+  AMBIGUOUS_RETENTION_MS,
+  pruneCodexOperationalData,
+};

package/lib/db/sessions.js

@@ -11,6 +11,26 @@ const path = require('path');
 
 function now() { return Date.now(); }
 
+const CLAUDE_INLINE_NAMESPACE = 'claude:inline';
+const CLAUDE_CHANNELS_NAMESPACE = 'claude:channels';
+const CODEX_APP_SERVER_NAMESPACE = 'codex:app-server';
+const CHANNELS_CLASS = new Set(['channels', 'cli']);
+
+/**
+ * Resolve the compatibility namespace from canonical runtime/backend identity.
+ * Historical stored `tmux` rows are inline. Current config `pm: "tmux"` is
+ * normalized to canonical `cli` before it reaches this resolver.
+ */
+function sessionNamespaceFor({ runtime = 'claude', backend = null } = {}) {
+  if (runtime === 'codex') return CODEX_APP_SERVER_NAMESPACE;
+  if (runtime !== 'claude') {
+    throw new TypeError(`unsupported provider runtime: ${runtime}`);
+  }
+  return CHANNELS_CLASS.has(backend)
+    ? CLAUDE_CHANNELS_NAMESPACE
+    : CLAUDE_INLINE_NAMESPACE;
+}
+
 function countSessions(db) {
   return db.raw.prepare('SELECT COUNT(*) AS c FROM sessions').get().c;
 }
@@ -95,6 +115,78 @@ function getClaudeSessionId(db, sessionKey) {
   return row?.claude_session_id || null;
 }
 
+function resolveProviderSessionForSpawn(db, sessionKey, resolved = {}) {
+  const namespace = sessionNamespaceFor(resolved);
+  if (!db) {
+    return {
+      existingSessionId: null,
+      appServerSessionId: null,
+      namespace,
+      drift: null,
+    };
+  }
+  if (resolved.runtime !== 'codex') {
+    const legacy = resolveSessionForSpawn(db, sessionKey, resolved);
+    const row = legacy.existingSessionId
+      ? db.getProviderSession(sessionKey, namespace)
+      : null;
+    return {
+      ...legacy,
+      appServerSessionId: null,
+      namespace,
+      providerSession: row ?? null,
+    };
+  }
+
+  const row = db.getProviderSession(sessionKey, namespace);
+  if (!row) {
+    return {
+      existingSessionId: null,
+      appServerSessionId: null,
+      namespace,
+      drift: null,
+    };
+  }
+  const before = {
+    agent: row.agent || null,
+    cwd: row.cwd || null,
+    model: row.model || null,
+    effort: row.effort || null,
+  };
+  const after = {
+    agent: resolved.agent || null,
+    cwd: resolved.cwd || null,
+    model: resolved.model || null,
+    effort: resolved.effort || null,
+  };
+  const fields = CODEX_SPAWN_IDENTITY_FIELDS.filter((field) => (
+    after[field] != null && after[field] !== before[field]
+  ));
+  if (fields.length > 0) {
+    db.clearProviderSession(sessionKey, namespace);
+    return {
+      existingSessionId: null,
+      appServerSessionId: null,
+      namespace,
+      drift: {
+        fields,
+        before: {
+          ...before,
+          provider_session_id: row.provider_session_id,
+        },
+        after,
+      },
+    };
+  }
+  return {
+    existingSessionId: row.provider_session_id,
+    appServerSessionId: row.app_server_session_id || null,
+    namespace,
+    drift: null,
+    providerSession: row,
+  };
+}
+
 // ─── S2: session-config drift ────────────────────────────────────────
 //
 // A stored `sessions` row records the config the claude session was
@@ -136,6 +228,10 @@ function getClaudeSessionId(db, sessionKey) {
 // already covers cleanly. The stored model/effort columns are
 // informational, not identity.
 const SPAWN_IDENTITY_FIELDS = ['agent', 'cwd'];
+// Codex model and effort are selected per turn and remain informational on
+// the provider-session row. Workspace drift still changes the static runtime
+// and security identity, so cwd is the sole invalidating field.
+const CODEX_SPAWN_IDENTITY_FIELDS = ['cwd'];
 
 /**
  * Decide whether a stored session can be resumed for the next spawn,
@@ -215,7 +311,6 @@ function resolveSessionForSpawn(db, sessionKey, resolved = {}) {
   // before 0.12 and a row created today with pm_backend='cli' are
   // semantically the same in terms of session-context invariants
   // (bridge MCP server mounted, reply-tool contract enforced).
-  const CHANNELS_CLASS = new Set(['channels', 'cli']);
   const wasChannelsClass = CHANNELS_CLASS.has(before.pm_backend);
   const willBeChannelsClass = CHANNELS_CLASS.has(after.pm_backend);
   if (after.pm_backend != null && wasChannelsClass !== willBeChannelsClass) {
@@ -244,4 +339,10 @@ module.exports = {
   resolveSessionForSpawn,
   countSessions,
   SPAWN_IDENTITY_FIELDS,
+  sessionNamespaceFor,
+  resolveProviderSessionForSpawn,
+  CLAUDE_INLINE_NAMESPACE,
+  CLAUDE_CHANNELS_NAMESPACE,
+  CODEX_APP_SERVER_NAMESPACE,
+  CODEX_SPAWN_IDENTITY_FIELDS,
 };