codehere 0.6.0 → 0.6.1

package/README.md

@@ -5,12 +5,12 @@
 
 [![npm](https://img.shields.io/npm/v/codehere)](https://www.npmjs.com/package/codehere)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow)](../LICENSE)
-[![Tests](https://img.shields.io/badge/tests-668%2F668-brightgreen)]()
+[![Tests](https://img.shields.io/badge/tests-1196%2F1196-brightgreen)]()
 [![Vulnerabilities](https://img.shields.io/badge/vulnerabilities-0-brightgreen)]()
 
 **Codehere is the vendor-neutral layer between you and the coding agents you already use** — Claude Code, Codex, Aider, Gemini, OpenCode. One `npm install`. Local-first, OSS, no account, no IAM, no compliance prereqs. Switch agent, keep your memory. End the day with one Final Report covering everything they did.
 
-Today, Claude Code gets full pre-execution safety-hook enforcement on every tool call; the other adapters are session-traced and reported, with per-tool hook parity in progress for v0.6. The vendor-neutral *memory*, *audit log*, and *Final Report* surfaces ship across all 5 adapters today.
+All 5 adapters (Claude Code, Codex, Aider, Gemini, OpenCode) get session-tracing, Final Reports, and trust scoring. Claude Code additionally gets full pre-execution safety-hook enforcement on every tool call. The *memory*, *audit log*, *failover*, and *Final Report* surfaces ship across all 5 adapters today.
 
 The enterprise tier is owned by [OpenAI Frontier](https://openai.com/index/introducing-openai-frontier/) (8-14 weeks of deploy prereqs, sales-team gated) and [Anthropic Cowork](https://www.anthropic.com/product/claude-cowork) (paid Claude subscription, single-vendor). Codehere fills the gap they structurally can't reach: **the individual / small-team / no-IT-department tier, vendor-neutral**.
 
@@ -29,7 +29,7 @@ One layer, every agent, your work stays portable.
 
 | | | |
 |---|---|---|
-| 1 | **Install** | `npm install -g codehere@alpha` (Node 20+) — current alpha track is v0.5; `@latest` still on v0.4 |
+| 1 | **Install** | `npm install -g codehere` (Node 20+) — v0.6.0 is the current stable |
 | 2 | **Detect environment** | `codehere setup` — checks API key, finds your repo |
 | 3 | **Install the safety hook** | `codehere hook install` — every Claude Code tool call now audited |
 | 4 | **Install at least one specialist** | Claude Code: `npm i -g @anthropic-ai/claude-code` (Codex / Aider / OpenCode / Gemini also supported · see [docs/integrations/](../docs/integrations/) for Cursor MCP setup) |
@@ -51,7 +51,7 @@ Context  +  End State  +  Constraints
 
 ### Folder convention (what `codehere init` writes)
 
-The v0.5 layout — F3 project memory:
+The v0.6 layout — F3 project memory:
 
 | Path | Purpose | Committed? |
 |---|---|---|
@@ -90,9 +90,9 @@ codehere report         # generates a shareable markdown audit report
 codehere status         # quick dashboard · sessions, blocks, trust trends
 ```
 
-The hook intercepts every `Bash`, `Edit`, `Write`, `MultiEdit`, and `NotebookEdit` call from any Claude Code session running on your machine, runs it through the trust-scorer pattern bank in under 5 ms, blocks anything matching the destructive / credential / injection patterns, and appends every decision to an append-only JSONL audit log at `~/.codehere/audit/`. (Hook coverage today is Claude Code-only — Codex / Aider / OpenCode adapters spawn through their native CLIs and emit to `~/.codehere/sessions.jsonl`; full hook parity across all adapters is v0.4 work.)
+The hook intercepts every `Bash`, `Edit`, `Write`, `MultiEdit`, and `NotebookEdit` call from any Claude Code session running on your machine, runs it through the trust-scorer pattern bank in under 5 ms, blocks anything matching the destructive / credential / injection patterns, and appends every decision to an append-only JSONL audit log at `~/.codehere/audit/`. Codex, Aider, OpenCode, and Gemini adapters spawn through their native CLIs and emit to `~/.codehere/sessions.jsonl` with per-tool tracing via the cross-vendor mirror hook.
 
-## Memory · F3 (v0.5)
+## Memory · F3 (v0.6)
 
 Once you've run `codehere init` in a project, every spawned agent — Claude Code, Codex, Aider, OpenCode, or Gemini — automatically reads the project's memory on entry. The agent starts warm with the briefing, recent lessons, and the most-referenced symbols in your codebase, instead of cold-grepping every session.
 
@@ -124,7 +124,7 @@ codehere memory show protocols    # safety patterns by category
 
 **Other memory commands:**
 - `codehere memory init` — migrate the v0.4.1 layout (`CONTEXT.md` / `HANDOVER.md` / `PROMPTS.md`) into the F3 layout (one shot, leaves back-compat symlinks; `--dry-run` previews)
-- `codehere memory repo-map [--rebuild]` — build the symbol map; v0.5 ships a TS-native MVP, v0.6 swaps in tree-sitter
+- `codehere memory repo-map [--rebuild]` — build the symbol map; currently TS-native MVP
 - `codehere protocols export [--rebuild]` — write the trust-scorer pattern bank to `.codehere/protocols/hook_patterns.json` for inspection / cross-tool ingestion
 
 ## Going deeper
@@ -204,7 +204,7 @@ For depth beyond this README:
 ## Requirements
 
 - **Node.js 20+** (pinned in `.nvmrc` and `engines.node`)
-- **macOS or Linux** · Windows via WSL works for development; native Windows is on the v0.4 roadmap
+- **macOS or Linux** · Windows via WSL works for development
 - **Optional but recommended:** at least one supported agent (Claude Code, Codex, Aider, OpenCode, or Gemini) installed before running `codehere start`
 
 ## License

package/dist/index.js

@@ -15,6 +15,16 @@ import { config } from 'dotenv';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { homedir } from 'os';
+// ── Global crash safety ───────────────────────────────────────────────────
+// Unhandled rejections and exceptions must never silently kill the daemon.
+process.on('unhandledRejection', (reason) => {
+    console.error('[codehere] unhandledRejection:', reason instanceof Error ? reason.stack : reason);
+});
+process.on('uncaughtException', (err) => {
+    console.error('[codehere] uncaughtException:', err.stack);
+    // persist what we can before dying
+    process.exitCode = 1;
+});
 import { executeSetupCommand } from './presentation/cli/commands/setup-command.js';
 import { executeInitCommand } from './presentation/cli/commands/init-command.js';
 import { executeMemoryCommand } from './presentation/cli/commands/memory-command.js';
@@ -464,6 +474,7 @@ program
             console.log(colors.dim('\ncodehere MCP server stopped'));
             process.exit(0);
         });
+        process.on('SIGTERM', () => process.exit(0));
         await new Promise((resolve) => {
             server.on('close', resolve);
         });
@@ -565,15 +576,30 @@ program
             startCloudSync();
         }
         await openBrowser();
-        process.on('SIGINT', () => {
+        const shutdown = () => {
+            try {
+                const { SessionManager } = require('./infrastructure/orchestration/session-manager.js');
+                SessionManager.getInstance().shutdown();
+            }
+            catch { /* graceful degradation — daemon may not have started fully */ }
             if (cloud) {
-                const { stopCloudSync } = require('./infrastructure/protocols/cloud-sync.js');
-                stopCloudSync();
+                try {
+                    const { stopCloudSync } = require('./infrastructure/protocols/cloud-sync.js');
+                    stopCloudSync();
+                }
+                catch { /* cloud sync may not be loaded */ }
             }
             server.close();
+        };
+        process.on('SIGINT', () => {
+            shutdown();
             console.log(colors.dim('\ncodehere stopped'));
             process.exit(0);
         });
+        process.on('SIGTERM', () => {
+            shutdown();
+            process.exit(0);
+        });
         await new Promise((resolve) => {
             server.on('close', resolve);
         });

package/dist/infrastructure/hooks/claude-sdk-hook.js

@@ -13,13 +13,20 @@
  *
  * Docs: https://docs.anthropic.com/en/docs/claude-code/hooks
  */
-import { appendFileSync, chmodSync, existsSync, mkdirSync, openSync, closeSync, readSync, statSync, readFileSync, } from 'fs';
+import { appendFileSync, chmodSync, existsSync, mkdirSync, openSync, closeSync, readSync, statSync, readFileSync, unlinkSync, } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
 import { createHash } from 'crypto';
 // P18 slice 2 — Tier 1 hook honors per-cwd permissions.yaml.
 import { filterAllowed } from '../security/permissions-config.js';
-const PATTERNS = [
+/**
+ * Instruction-level scan pattern bank used by `scanPayload()`. Exported so
+ * docs and the landing page can quote `PATTERNS.length` instead of hardcoding
+ * a number that silently drifts (May 2026 audit found 50 / 47 / 60+ all in
+ * the same PRD). Pair this with `CODE_PATTERNS` from `trust-scorer.ts` — the
+ * two banks are scanned in different passes and counted separately.
+ */
+export const PATTERNS = [
     // Prompt Injection
     // Allow chained modifiers: "ignore all previous instructions", "ignore all your prior rules", etc.
     {
@@ -494,6 +501,38 @@ function readChainTip(filepath) {
     return null;
 }
 export function appendAuditLog(entry) {
+    // Cross-process file locking. Multiple Claude Code sessions (e.g., two
+    // terminals, or IDE + terminal) can trigger PreToolUse concurrently.
+    // Without a lock, two hook processes read the same chain tip and both
+    // write seq 43 — corrupting the hash chain. We use an exclusive-create
+    // lock file (+O_EXCL) which is atomic on all POSIX systems.
+    const LOCK_FILE = AUDIT_FILE + '.lock';
+    const lockAcquired = () => {
+        for (let attempt = 0; attempt < 20; attempt++) {
+            try {
+                const fd = openSync(LOCK_FILE, 'wx');
+                closeSync(fd);
+                return true;
+            }
+            catch {
+                // Lock held by another process — spin-wait ~10ms
+                const deadline = Date.now() + 10;
+                while (Date.now() < deadline) { /* busy-wait — sync context */ }
+            }
+        }
+        return false;
+    };
+    const lockReleased = () => {
+        try {
+            unlinkSync(LOCK_FILE);
+        }
+        catch { /* best effort */ }
+    };
+    if (!lockAcquired()) {
+        // Fall through unlocked rather than drop the entry. The entry still
+        // appends; verification may flag a chain break, but the audit data
+        // is preserved.
+    }
     try {
         const dir = AUDIT_FILE.substring(0, AUDIT_FILE.lastIndexOf('/'));
         if (dir && !existsSync(dir)) {
@@ -526,6 +565,9 @@ export function appendAuditLog(entry) {
     catch {
         // Audit log failure must not block tool execution
     }
+    finally {
+        lockReleased();
+    }
 }
 /**
  * Walk the audit file and verify the hash chain. Returns:

package/dist/infrastructure/orchestration/opencode-adapter.js

@@ -19,6 +19,7 @@ import { join } from 'path';
 import { promisify } from 'util';
 import { ProgressAggregator } from './progress-aggregator.js';
 import { applyMemoryPrefix } from './memory-injector.js';
+import { mirrorToolCallToAudit } from '../hooks/mirror-tool-call-to-audit.js';
 import { snapshotCwd, extractArtifacts } from './artifacts-extractor.js';
 const execFileAsync = promisify(execFile);
 const HEADLESS_FLAGS = ['run', '--format', 'json'];
@@ -142,6 +143,46 @@ export function spawnOpenCode(prompt, options = {}) {
             if (txt)
                 textAccum += txt + '\n';
         }
+        // #114 — cross-vendor audit mirror for opencode (closes the gap left by
+        // #110 slice 4, which wired Codex/Aider/Gemini but deferred opencode).
+        // OpenCode's `run --format json` emits `tool_use` events with shape
+        // { type: 'tool_use', part: { tool: 'bash'|'read'|'write'|..., state:
+        // { input: {...}, output, status, ... } } } (verified via deepwiki +
+        // takopi cheatsheet). Same post-hoc visibility surface as Codex/Aider/
+        // Gemini — no synchronous block until upstream pre-tool hooks land.
+        if (event.type === 'tool_use') {
+            const part = event.data?.part;
+            const rawTool = String(part?.tool ?? 'tool').toLowerCase();
+            // Normalize to Claude-cased tool names so /history filter chips group
+            // cross-vendor (a bash call from claude-code and opencode show under
+            // the same "Bash" filter chip).
+            const toolNameMap = {
+                bash: 'Bash',
+                read: 'Read',
+                write: 'Write',
+                edit: 'Edit',
+                grep: 'Grep',
+                glob: 'Glob',
+                webfetch: 'WebFetch',
+                websearch: 'WebSearch',
+                task: 'Task',
+            };
+            const toolName = toolNameMap[rawTool] ?? rawTool;
+            const input = part?.state?.input ?? {};
+            const inputStr = (typeof input.command === 'string' && input.command) ||
+                (typeof input.file_path === 'string' && input.file_path) ||
+                (typeof input.path === 'string' && input.path) ||
+                (typeof input.pattern === 'string' && input.pattern) ||
+                (typeof input.query === 'string' && input.query) ||
+                JSON.stringify(input).slice(0, 500);
+            mirrorToolCallToAudit({
+                sessionId,
+                agent: 'opencode',
+                toolName,
+                toolInput: String(inputStr),
+                cwd,
+            });
+        }
         if (!errorEmitted) {
             const data = event.data;
             let text = '';

package/dist/infrastructure/orchestration/session-manager.js

@@ -108,7 +108,14 @@ function parseEtime(s) {
     return 0;
 }
 export class SessionManager {
+    /** Max completed sessions kept in memory. Older sessions are evicted to
+     *  prevent unbounded memory growth in the internal tracking maps. The data
+     *  survives on disk via sessions.jsonl + thread.jsonl. */
+    static MAX_COMPLETED_SESSIONS = 100;
     sessions = new Map();
+    /** Spawn order FIFO — used to evict oldest completed sessions when the cap
+     *  is reached. Pushed on spawn, referenced by evictOldCompleted(). */
+    spawnOrder = [];
     /** Read-only sessions replayed from ~/.codehere/sessions.jsonl on daemon start.
      *  These subprocesses are long-dead; we surface them so the user doesn't lose
      *  their Final reports across restarts. */
@@ -150,7 +157,7 @@ export class SessionManager {
     continuedAsBySession = new Map();
     continuedFromBySession = new Map();
     /** Final Report failure tracking — when generateFinalReport rejects, we
-      *  record it so the API can return a definitive "failed" state instead
+      *  record it so the API can return a definitive "failed" status instead
       *  of leaving the UI showing "Generating report…" forever. */
     failedReportBySession = new Set();
     spawn(prompt, agentId = 'claude-code', options) {
@@ -187,6 +194,7 @@ export class SessionManager {
         const enrichedPrompt = enrichPromptWithPackSync(prompt, cwd);
         const session = adapter.spawn(enrichedPrompt, options);
         this.sessions.set(session.sessionId, session);
+        this.spawnOrder.push(session.sessionId);
         // Persistence: write the spawned record immediately so a daemon crash still
         // leaves an audit trail of what was attempted. Subscribe to exit so we can
         // capture the final status + steps + artifacts when the session settles.
@@ -317,6 +325,7 @@ export class SessionManager {
                 clearInterval(t);
                 this.narrationTimers.delete(session.sessionId);
             }
+            this.evictOldCompleted();
             unsubscribe();
         });
         // v0.6 M3 — PM Narrator. Mid-task plain-English summaries fired
@@ -388,29 +397,10 @@ export class SessionManager {
                 });
                 // Track this new session in the same way
                 this.sessions.set(newSession.sessionId, newSession);
+                this.spawnOrder.push(newSession.sessionId);
                 this.cwdBySession.set(newSession.sessionId, cwd);
-                appendSpawned({
-                    id: newSession.sessionId,
-                    agent: newSession.agent,
-                    prompt: promptWithHandoff,
-                    cwd,
-                    startedAt: newSession.startedAt,
-                });
-                mirrorSpawnedToThread({
-                    sessionId: newSession.sessionId,
-                    agent: newSession.agent,
-                    prompt: promptWithHandoff,
-                    cwd,
-                    startedAt: newSession.startedAt,
-                });
-                mirrorFailoverToThread({
-                    sessionId: newSession.sessionId,
-                    fromAgent: signal.fromAgent,
-                    toAgent: target,
-                    reason: signal.errorCode,
-                    cwd,
-                });
-                // Subscribe to the new session with the same failover logic
+                // Subscribe BEFORE persistence so exit events are never lost if the
+                // adapter exits synchronously (command not found, instant crash, etc).
                 const unsubscribe = newSession.subscribe((event) => {
                     if (event.type !== 'exit')
                         return;
@@ -482,8 +472,36 @@ export class SessionManager {
                         clearInterval(t);
                         this.narrationTimers.delete(newSession.sessionId);
                     }
+                    this.evictOldCompleted();
                     unsubscribe();
                 });
+                // Persistence + threading — safe after subscribe because the exit
+                // handler is already registered. These can run even if the session
+                // already exited (spawned record still useful, exit handler handles
+                // the completion).
+                appendSpawned({
+                    id: newSession.sessionId,
+                    agent: newSession.agent,
+                    prompt: promptWithHandoff,
+                    cwd,
+                    startedAt: newSession.startedAt,
+                });
+                mirrorSpawnedToThread({
+                    sessionId: newSession.sessionId,
+                    agent: newSession.agent,
+                    prompt: promptWithHandoff,
+                    cwd,
+                    startedAt: newSession.startedAt,
+                });
+                mirrorFailoverToThread({
+                    sessionId: newSession.sessionId,
+                    fromAgent: signal.fromAgent,
+                    toAgent: target,
+                    reason: signal.errorCode,
+                    cwd,
+                });
+                this.continuedAsBySession.set(session.sessionId, newSession.sessionId);
+                this.continuedFromBySession.set(newSession.sessionId, session.sessionId);
                 this.startNarrationTimer(newSession);
                 return newSession;
             }
@@ -501,13 +519,12 @@ export class SessionManager {
     /** Emitted when a failover offer is generated. The API layer listens
      *  to this to surface the banner in the web UI. */
     emitFailoverOffer(offer) {
-        // Store in a map that the API layer can poll — Slice E wires the
-        // /api/failover-offers endpoint to read from here.
         if (!this.failoverOffers) {
             this.failoverOffers = new Map();
         }
         const key = `${offer.session.sessionId}-${offer.target}`;
-        this.failoverOffers.set(key, offer);
+        const expiresAt = Date.now() + 60_000;
+        this.failoverOffers.set(key, { offer, createdAt: Date.now() });
         // Auto-expire offers after 60 seconds to keep the map bounded
         setTimeout(() => {
             this.failoverOffers?.delete(key);
@@ -518,12 +535,12 @@ export class SessionManager {
         if (!this.failoverOffers)
             return [];
         const offers = [];
-        for (const [key, offer] of this.failoverOffers) {
+        for (const [key, { offer, createdAt }] of this.failoverOffers) {
             offers.push({
                 sessionId: offer.session.sessionId,
                 signal: offer.signal,
                 target: offer.target,
-                expiresAt: Date.now() + 60_000,
+                expiresAt: createdAt + 60_000,
             });
         }
         return offers;
@@ -565,32 +582,10 @@ export class SessionManager {
         });
         // Track the new session
         this.sessions.set(newSession.sessionId, newSession);
+        this.spawnOrder.push(newSession.sessionId);
         this.cwdBySession.set(newSession.sessionId, cwd);
-        // Session threading: record the parent-child relationship
-        this.continuedAsBySession.set(sessionId, newSession.sessionId);
-        this.continuedFromBySession.set(newSession.sessionId, sessionId);
-        appendSpawned({
-            id: newSession.sessionId,
-            agent: newSession.agent,
-            prompt: promptWithHandoff,
-            cwd,
-            startedAt: newSession.startedAt,
-        });
-        mirrorSpawnedToThread({
-            sessionId: newSession.sessionId,
-            agent: newSession.agent,
-            prompt: promptWithHandoff,
-            cwd,
-            startedAt: newSession.startedAt,
-        });
-        mirrorFailoverToThread({
-            sessionId: newSession.sessionId,
-            fromAgent: session.agent,
-            toAgent: targetAgent,
-            reason: this.failoverReasonBySession.get(session.sessionId) ?? 'error',
-            cwd,
-        });
-        // Subscribe to the new session with the same failover logic
+        // Subscribe BEFORE persistence so exit events are never lost if the
+        // adapter exits synchronously.
         const unsubscribe = newSession.subscribe((event) => {
             if (event.type !== 'exit')
                 return;
@@ -662,9 +657,34 @@ export class SessionManager {
                 clearInterval(t);
                 this.narrationTimers.delete(newSession.sessionId);
             }
-            this.startNarrationTimer(newSession);
+            this.evictOldCompleted();
             unsubscribe();
         });
+        // Persistence + threading — safe after subscribe because the exit
+        // handler is already registered.
+        this.continuedAsBySession.set(sessionId, newSession.sessionId);
+        this.continuedFromBySession.set(newSession.sessionId, sessionId);
+        appendSpawned({
+            id: newSession.sessionId,
+            agent: newSession.agent,
+            prompt: promptWithHandoff,
+            cwd,
+            startedAt: newSession.startedAt,
+        });
+        mirrorSpawnedToThread({
+            sessionId: newSession.sessionId,
+            agent: newSession.agent,
+            prompt: promptWithHandoff,
+            cwd,
+            startedAt: newSession.startedAt,
+        });
+        mirrorFailoverToThread({
+            sessionId: newSession.sessionId,
+            fromAgent: session.agent,
+            toAgent: targetAgent,
+            reason: this.failoverReasonBySession.get(session.sessionId) ?? 'error',
+            cwd,
+        });
         this.startNarrationTimer(newSession);
         return newSession;
     }
@@ -744,6 +764,38 @@ export class SessionManager {
     get(sessionId) {
         return this.sessions.get(sessionId);
     }
+    /** Evict the oldest completed sessions when the in-memory cap is reached.
+     *  Prevents unbounded memory growth in the internal tracking maps. The
+     *  data survives on disk via sessions.jsonl + thread.jsonl. */
+    evictOldCompleted() {
+        const completed = [];
+        for (const id of this.spawnOrder) {
+            const at = this.completedAtBySession.get(id);
+            if (at !== undefined)
+                completed.push({ id, completedAt: at });
+        }
+        if (completed.length <= SessionManager.MAX_COMPLETED_SESSIONS)
+            return;
+        const toEvict = completed.slice(0, completed.length - SessionManager.MAX_COMPLETED_SESSIONS);
+        const evictSet = new Set(toEvict.map((e) => e.id));
+        for (const id of evictSet) {
+            const t = this.narrationTimers.get(id);
+            if (t) {
+                clearInterval(t);
+                this.narrationTimers.delete(id);
+            }
+            this.sessions.delete(id);
+            this.completedAtBySession.delete(id);
+            this.cwdBySession.delete(id);
+            this.finalReportBySession.delete(id);
+            this.narrationBySession.delete(id);
+            this.failoverReasonBySession.delete(id);
+            this.continuedAsBySession.delete(id);
+            this.continuedFromBySession.delete(id);
+            this.failedReportBySession.delete(id);
+            this.failoverTriedBySession.delete(id);
+        }
+    }
     list() {
         return Array.from(this.sessions.values());
     }
@@ -754,6 +806,17 @@ export class SessionManager {
         session.kill();
         return true;
     }
+    /** Graceful shutdown: kill all running sessions and clear all timers. */
+    shutdown() {
+        for (const [id, timer] of this.narrationTimers) {
+            clearInterval(timer);
+        }
+        this.narrationTimers.clear();
+        for (const session of this.sessions.values()) {
+            if (session.status === 'running')
+                session.kill();
+        }
+    }
     /**
      * Active Claude Code sessions on this machine, derived from the audit log.
      * A session is "active" if any tool call from it was recorded within the
@@ -879,5 +942,19 @@ export class SessionManager {
     static getInstance() {
         return (this._instance ??= new SessionManager());
     }
+    /** @internal Resets the singleton for test isolation. */
+    static __testOnlyReset() {
+        this._instance = undefined;
+    }
+}
+// ── Test seam ─────────────────────────────────────────────────────────────────
+// Avoids refactoring the module-level REGISTRY const to DI. Usage:
+//   import { __testOnlyRegisterAdapter, SessionManager } from '...';
+//   __testOnlyRegisterAdapter(mockAdapter);
+//   SessionManager.__testOnlyReset();
+//   const sm = SessionManager.getInstance();
+/** @internal Exported for testing only — allows mock adapter injection. */
+export function __testOnlyRegisterAdapter(adapter) {
+    REGISTRY.push(adapter);
 }
 //# sourceMappingURL=session-manager.js.map