harnery 0.9.0 → 0.11.0

package/src/lib/claude-desktop.ts

@@ -0,0 +1,293 @@
+import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, join } from "node:path";
+
+/**
+ * Claude desktop app session-index access.
+ *
+ * The Claude desktop app keeps each signed-in account's Claude Code session
+ * sidebar as plain JSON files:
+ *
+ *   <dataDir>/claude-code-sessions/<account-uuid>/<env-id>/local_<uuid>.json
+ *
+ * One file per sidebar entry: { sessionId, cliSessionId, cwd, title, ... }.
+ * Nothing inside the file binds it to an account — the scoping is purely
+ * which <account-uuid> directory it sits in, and the transcripts themselves
+ * live in the (account-agnostic) `~/.claude/projects/` tree of the runtime
+ * environment. So when a user signs out of account A and into account B,
+ * their sessions "disappear" from the sidebar even though every byte is
+ * still on disk. Copying an entry file into another account's directory
+ * makes the session visible (and resumable) there.
+ *
+ * These helpers locate the desktop app's data directory (including the
+ * Windows one from inside WSL, where the app runs on the Windows side but
+ * the CLI runs in the distro), enumerate the per-account entries, and
+ * plan/apply cross-account mirrors. The file format is the desktop app's
+ * private state, not a public API — everything here treats it read-mostly
+ * and copies files verbatim rather than rewriting them.
+ */
+
+export interface DesktopSessionEntry {
+  /** Absolute path of the local_*.json entry file. */
+  file: string;
+  /** Account UUID directory the entry sits under (= sidebar scoping). */
+  accountUuid: string;
+  /** Environment directory between account and entry (VM/env identity). */
+  envId: string;
+  /** The entry's own id (usually "local_<uuid>", mirrors the filename). */
+  sessionId: string | null;
+  /** The Claude Code session id — matches the JSONL transcript filename. */
+  cliSessionId: string | null;
+  cwd: string | null;
+  title: string | null;
+  model: string | null;
+  isArchived: boolean;
+  createdAt: number | null;
+  lastActivityAt: number | null;
+}
+
+export interface DesktopAccount {
+  accountUuid: string;
+  path: string;
+  entries: DesktopSessionEntry[];
+}
+
+export interface MirrorAction {
+  from: string;
+  to: string;
+  entry: DesktopSessionEntry;
+  targetAccountUuid: string;
+}
+
+export interface MirrorPlan {
+  actions: MirrorAction[];
+  /** Entries skipped because the target already lists that cliSessionId. */
+  skippedExisting: number;
+  /** Entries skipped because they are archived (opt in via includeArchived). */
+  skippedArchived: number;
+}
+
+const SESSIONS_DIRNAME = "claude-code-sessions";
+
+function isWsl(): boolean {
+  if (process.env.WSL_DISTRO_NAME) return true;
+  try {
+    return readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft");
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Candidate desktop-app data directories for this machine, most specific
+ * first. Only directories that exist AND contain a claude-code-sessions/
+ * subdirectory are returned. Precedence: explicit arg, then
+ * HARNERY_CLAUDE_DESKTOP_DIR, then platform defaults (on WSL that means
+ * scanning every /mnt/c/Users/<user>/AppData/Roaming/Claude).
+ */
+export function findDesktopDataDirs(explicit?: string): string[] {
+  const candidates: string[] = [];
+  if (explicit) candidates.push(explicit);
+  else if (process.env.HARNERY_CLAUDE_DESKTOP_DIR) {
+    candidates.push(process.env.HARNERY_CLAUDE_DESKTOP_DIR);
+  } else {
+    const home = homedir();
+    if (process.platform === "darwin") {
+      candidates.push(join(home, "Library", "Application Support", "Claude"));
+    } else if (process.platform === "win32") {
+      if (process.env.APPDATA) candidates.push(join(process.env.APPDATA, "Claude"));
+      candidates.push(join(home, "AppData", "Roaming", "Claude"));
+    } else {
+      candidates.push(join(home, ".config", "Claude"));
+      if (isWsl()) {
+        for (const usersRoot of ["/mnt/c/Users"]) {
+          if (!existsSync(usersRoot)) continue;
+          for (const user of safeReaddir(usersRoot)) {
+            candidates.push(join(usersRoot, user, "AppData", "Roaming", "Claude"));
+          }
+        }
+      }
+    }
+  }
+  const seen = new Set<string>();
+  const out: string[] = [];
+  for (const dir of candidates) {
+    if (seen.has(dir)) continue;
+    seen.add(dir);
+    if (existsSync(join(dir, SESSIONS_DIRNAME))) out.push(dir);
+  }
+  return out;
+}
+
+function safeReaddir(dir: string): string[] {
+  try {
+    return readdirSync(dir);
+  } catch {
+    return [];
+  }
+}
+
+function isDir(p: string): boolean {
+  try {
+    return statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+function readEntry(file: string, accountUuid: string, envId: string): DesktopSessionEntry | null {
+  let raw: unknown;
+  try {
+    raw = JSON.parse(readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+  if (typeof raw !== "object" || raw === null) return null;
+  const d = raw as Record<string, unknown>;
+  const str = (k: string): string | null => (typeof d[k] === "string" ? (d[k] as string) : null);
+  const num = (k: string): number | null => (typeof d[k] === "number" ? (d[k] as number) : null);
+  return {
+    file,
+    accountUuid,
+    envId,
+    sessionId: str("sessionId"),
+    cliSessionId: str("cliSessionId"),
+    cwd: str("cwd"),
+    title: str("title"),
+    model: str("model"),
+    isArchived: d.isArchived === true,
+    createdAt: num("createdAt"),
+    lastActivityAt: num("lastActivityAt"),
+  };
+}
+
+/** Enumerate every account directory + its session entries under one data dir. */
+export function listAccounts(dataDir: string): DesktopAccount[] {
+  const root = join(dataDir, SESSIONS_DIRNAME);
+  const accounts: DesktopAccount[] = [];
+  for (const accountUuid of safeReaddir(root)) {
+    const accountPath = join(root, accountUuid);
+    if (!isDir(accountPath)) continue;
+    const entries: DesktopSessionEntry[] = [];
+    for (const envId of safeReaddir(accountPath)) {
+      const envPath = join(accountPath, envId);
+      if (!isDir(envPath)) continue;
+      for (const f of safeReaddir(envPath)) {
+        if (!f.endsWith(".json")) continue;
+        const entry = readEntry(join(envPath, f), accountUuid, envId);
+        if (entry) entries.push(entry);
+      }
+    }
+    entries.sort((a, b) => (b.lastActivityAt ?? 0) - (a.lastActivityAt ?? 0));
+    accounts.push({ accountUuid, path: accountPath, entries });
+  }
+  accounts.sort(
+    (a, b) =>
+      (b.entries[0]?.lastActivityAt ?? 0) - (a.entries[0]?.lastActivityAt ?? 0) ||
+      a.accountUuid.localeCompare(b.accountUuid),
+  );
+  return accounts;
+}
+
+/**
+ * The account the runtime environment's Claude Code CLI is signed into,
+ * read from ~/.claude.json (best-effort; null when unavailable). Lets the
+ * command label an otherwise-opaque account UUID with an email address.
+ */
+export function readCliAccount(): { accountUuid: string; email: string | null } | null {
+  try {
+    const raw = JSON.parse(readFileSync(join(homedir(), ".claude.json"), "utf8")) as Record<
+      string,
+      unknown
+    >;
+    const oa = raw.oauthAccount as Record<string, unknown> | undefined;
+    if (!oa || typeof oa.accountUuid !== "string") return null;
+    return {
+      accountUuid: oa.accountUuid,
+      email: typeof oa.emailAddress === "string" ? oa.emailAddress : null,
+    };
+  } catch {
+    return null;
+  }
+}
+
+export interface MirrorOptions {
+  /** Restrict targets to accounts whose uuid starts with one of these. */
+  to?: string[];
+  /** Restrict sources to accounts whose uuid starts with one of these. */
+  from?: string[];
+  /**
+   * Selectors: each matches a cliSessionId / sessionId exactly, or a title
+   * case-insensitively as a substring. Empty/undefined = every entry.
+   */
+  sessions?: string[];
+  includeArchived?: boolean;
+}
+
+export function entryMatchesSelector(entry: DesktopSessionEntry, selector: string): boolean {
+  if (entry.cliSessionId === selector || entry.sessionId === selector) return true;
+  return entry.title !== null && entry.title.toLowerCase().includes(selector.toLowerCase());
+}
+
+/**
+ * Plan the copies that would make each target account list the selected
+ * sessions. Union semantics: every entry a source account has and a target
+ * account lacks (keyed by cliSessionId, falling back to filename) becomes a
+ * copy action. Idempotent by construction — planning again after applying
+ * yields zero actions.
+ */
+export function planMirror(accounts: DesktopAccount[], opts: MirrorOptions = {}): MirrorPlan {
+  const matchPrefix = (uuid: string, prefixes?: string[]) =>
+    !prefixes || prefixes.length === 0 || prefixes.some((p) => uuid.startsWith(p));
+
+  const targets = accounts.filter((a) => matchPrefix(a.accountUuid, opts.to));
+  const sources = accounts.filter((a) => matchPrefix(a.accountUuid, opts.from));
+
+  const actions: MirrorAction[] = [];
+  let skippedExisting = 0;
+  let skippedArchived = 0;
+
+  for (const target of targets) {
+    const have = new Set<string>();
+    for (const e of target.entries) {
+      if (e.cliSessionId) have.add(e.cliSessionId);
+      have.add(basename(e.file));
+    }
+    for (const source of sources) {
+      if (source.accountUuid === target.accountUuid) continue;
+      for (const entry of source.entries) {
+        if (opts.sessions?.length && !opts.sessions.some((s) => entryMatchesSelector(entry, s))) {
+          continue;
+        }
+        const key = entry.cliSessionId ?? basename(entry.file);
+        if (have.has(key) || have.has(basename(entry.file))) {
+          skippedExisting++;
+          continue;
+        }
+        if (entry.isArchived && !opts.includeArchived) {
+          skippedArchived++;
+          continue;
+        }
+        have.add(key);
+        actions.push({
+          from: entry.file,
+          to: join(target.path, entry.envId, basename(entry.file)),
+          entry,
+          targetAccountUuid: target.accountUuid,
+        });
+      }
+    }
+  }
+  return { actions, skippedExisting, skippedArchived };
+}
+
+/** Apply a plan: verbatim file copies (never rewrites entry contents). */
+export function applyMirror(plan: MirrorPlan): { copied: number } {
+  let copied = 0;
+  for (const action of plan.actions) {
+    mkdirSync(dirname(action.to), { recursive: true });
+    copyFileSync(action.from, action.to);
+    copied++;
+  }
+  return { copied };
+}

package/src/lib/docs-lint.ts

@@ -61,8 +61,10 @@ export interface LintOpts {
 /** Files allowed at a submodule root level. Includes:
  *  - In-repo conventions: README.md, CLAUDE.md, LLM-BRIEFING.md, AGENTS.md
  *  - GitHub OSS conventions: CHANGELOG.md, CONTRIBUTING.md, CODE_OF_CONDUCT.md,
- *    SECURITY.md, SUPPORT.md, AUTHORS.md, MAINTAINERS.md, PULL_REQUEST_TEMPLATE.md
- *    (these are recognized by the GitHub UI, and renaming them breaks the integration)
+ *    LICENSE.md, SECURITY.md, SUPPORT.md, AUTHORS.md, MAINTAINERS.md,
+ *    PULL_REQUEST_TEMPLATE.md (these are recognized by the GitHub UI, and
+ *    renaming them breaks the integration; LICENSE.md also appears inside
+ *    vendored upstream trees, where renaming would damage provenance)
  */
 const ROOT_FILE_ALLOWLIST = new Set([
   "README.md",
@@ -73,6 +75,7 @@ const ROOT_FILE_ALLOWLIST = new Set([
   "CHANGELOG.md",
   "CONTRIBUTING.md",
   "CODE_OF_CONDUCT.md",
+  "LICENSE.md",
   "SECURITY.md",
   "SUPPORT.md",
   "AUTHORS.md",

package/src/lib/identities/assume.ts

@@ -0,0 +1,363 @@
+/**
+ * Bind a live session to a durable agent persona.
+ *
+ * The operation is serialized because "is this name live?" and "claim it"
+ * must be one critical section. Authoritative state is written twice on
+ * purpose: `.name-history` heals a missing heartbeat, while the canonical
+ * `identity.assumed` event makes replay and derived readers converge.
+ *
+ * Local collision policy: a fresh heartbeat alone is not enough to block.
+ * If the namesake has no live pid-map process (crashed session, healed
+ * zombie, or abandoned harness), reclaim that heartbeat and continue.
+ * Refuse only when another process is still alive, or when cached remote
+ * presence reports the name.
+ */
+
+import { randomUUID } from "node:crypto";
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  statSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+
+import { emitAndProject } from "../../core/agents/cli-emit.ts";
+import { emit } from "../../core/agents/events/emit.ts";
+import { type Heartbeat, readHeartbeat } from "../../core/agents/state/heartbeat-writer.ts";
+import { recordNameAssumption } from "../../core/agents/state/names.ts";
+import { instanceHasLivePid, removePidmapRowsForInstance } from "../../core/agents/state/pidmap.ts";
+import { coordFreshnessSeconds } from "../../core/config.ts";
+import { readRemoteMachines } from "../../core/presence/index.ts";
+import { type AgentIdentity, bareName, ensureIdentity, lookupById, lookupByName } from "./index.ts";
+
+const ASSUME_LOCK = "identity-assume.lock";
+const ASSUME_LOCK_STALE_MS = 30_000;
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+export type IdentityAssumeErrorCode =
+  | "identity_busy"
+  | "identity_in_use"
+  | "identity_not_found"
+  | "invalid_identity"
+  | "no_heartbeat"
+  | "not_session"
+  | "projection_failed";
+
+export class IdentityAssumeError extends Error {
+  constructor(
+    public readonly code: IdentityAssumeErrorCode,
+    message: string,
+  ) {
+    super(message);
+    this.name = "IdentityAssumeError";
+  }
+}
+
+export interface IdentityConflict {
+  instance_id: string;
+  name: string;
+  scope: "local" | "remote";
+  machine?: string;
+}
+
+export interface IdentityAssumeResult {
+  changed: boolean;
+  instance_id: string;
+  session_id: string;
+  previous_name: string | null;
+  previous_agent_id: string | null;
+  name: string;
+  agent_id: string;
+  identity_created: boolean;
+  event_id: string | null;
+  /** Prior local holder swept because it had no live process. */
+  reclaimed_instance_id: string | null;
+}
+
+function heartbeatIsFresh(hb: Heartbeat, cutoffMs: number): boolean {
+  const ts = Date.parse(hb.last_heartbeat);
+  return Number.isFinite(ts) && ts >= cutoffMs;
+}
+
+/** Best-effort collision read across local heartbeats and cached remote
+ * presence. No network call occurs; absent presence degrades to local-only. */
+export function findIdentityConflict(
+  coordRoot: string,
+  instanceId: string,
+  name: string,
+  nowMs = Date.now(),
+): IdentityConflict | null {
+  const wanted = name.toLowerCase();
+  const cutoffMs = nowMs - coordFreshnessSeconds(coordRoot) * 1000;
+  const activeDir = join(coordRoot, ".harnery", "active");
+  if (existsSync(activeDir)) {
+    for (const file of readdirSync(activeDir)) {
+      if (!file.endsWith(".json")) continue;
+      try {
+        const hb = JSON.parse(readFileSync(join(activeDir, file), "utf8")) as Heartbeat;
+        if (hb.instance_id === instanceId || !heartbeatIsFresh(hb, cutoffMs)) continue;
+        if ((hb.name ?? "").toLowerCase() === wanted) {
+          return { instance_id: hb.instance_id, name: hb.name ?? name, scope: "local" };
+        }
+      } catch {
+        // Malformed heartbeats are handled by stale sweep, not this command.
+      }
+    }
+  }
+
+  for (const remote of readRemoteMachines(coordRoot)) {
+    for (const agent of remote.agents) {
+      if (agent.instance_id === instanceId) continue;
+      if ((agent.name ?? "").toLowerCase() === wanted) {
+        return {
+          instance_id: agent.instance_id,
+          name: agent.name ?? name,
+          scope: "remote",
+          machine: remote.machine,
+        };
+      }
+    }
+  }
+  return null;
+}
+
+/**
+ * Drop a local namesake whose harness process is gone. Fresh heartbeats can
+ * linger after a crash (or after heartbeat heal without a live pid-map), and
+ * `identity assume` is the supported takeover path — operators should not
+ * need a separate kill/sweep step.
+ */
+export function reclaimAbandonedLocalConflict(
+  coordRoot: string,
+  conflict: IdentityConflict,
+): boolean {
+  if (conflict.scope !== "local") return false;
+  if (instanceHasLivePid(coordRoot, conflict.instance_id)) return false;
+
+  const hbPath = join(coordRoot, ".harnery", "active", `${conflict.instance_id}.json`);
+  let harness: "claude-code" | "cursor" | "codex" = "claude-code";
+  let sessionId = conflict.instance_id;
+  let ageSecs: number | undefined;
+  if (existsSync(hbPath)) {
+    try {
+      const hb = JSON.parse(readFileSync(hbPath, "utf8")) as Heartbeat;
+      harness = harnessOf(hb.platform);
+      sessionId = hb.session_id || conflict.instance_id;
+      const ts = Date.parse(hb.last_heartbeat);
+      if (Number.isFinite(ts)) ageSecs = Math.max(0, Math.floor((Date.now() - ts) / 1000));
+    } catch {
+      /* content unreadable — still reclaim the file */
+    }
+    try {
+      unlinkSync(hbPath);
+    } catch {
+      return false;
+    }
+  }
+  removePidmapRowsForInstance(coordRoot, conflict.instance_id);
+  try {
+    emit(coordRoot, {
+      event_type: "health.heartbeat_swept",
+      instance_id: conflict.instance_id,
+      session_id: sessionId,
+      harness,
+      source: "agent-coord",
+      data: {
+        reason: "stale",
+        ...(ageSecs !== undefined ? { age_secs: ageSecs } : {}),
+        reclaimed_by: "identity.assume",
+      },
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    } as Parameters<typeof emit>[1]);
+  } catch {
+    /* telemetry only */
+  }
+  return true;
+}
+
+function resolveTarget(
+  coordRoot: string,
+  input: string,
+): {
+  identity: AgentIdentity | null;
+  name: string;
+} {
+  const trimmed = input.trim();
+  if (!trimmed) {
+    throw new IdentityAssumeError("invalid_identity", "identity name cannot be empty");
+  }
+  if (UUID_RE.test(trimmed)) {
+    const identity = lookupById(trimmed, coordRoot);
+    if (!identity) {
+      throw new IdentityAssumeError(
+        "identity_not_found",
+        `no durable identity matching '${trimmed}'`,
+      );
+    }
+    return { identity, name: identity.name };
+  }
+
+  const name = bareName(trimmed);
+  if (!name) {
+    throw new IdentityAssumeError("invalid_identity", "identity name cannot be empty");
+  }
+  const existing = lookupByName(name, coordRoot);
+  return { identity: existing, name: existing?.name ?? name };
+}
+
+function acquireLock(coordRoot: string): () => void {
+  const dir = join(coordRoot, ".harnery");
+  const path = join(dir, ASSUME_LOCK);
+  mkdirSync(dir, { recursive: true });
+  const token = `${process.pid}:${randomUUID()}`;
+
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      writeFileSync(path, token, { encoding: "utf8", flag: "wx" });
+      return () => {
+        try {
+          if (readFileSync(path, "utf8") === token) unlinkSync(path);
+        } catch {
+          // The critical section completed; a missing lock needs no recovery.
+        }
+      };
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;
+      try {
+        if (Date.now() - statSync(path).mtimeMs > ASSUME_LOCK_STALE_MS) {
+          unlinkSync(path);
+          continue;
+        }
+      } catch {
+        continue;
+      }
+      break;
+    }
+  }
+  throw new IdentityAssumeError(
+    "identity_busy",
+    "another identity assumption is in progress; retry in a moment",
+  );
+}
+
+function harnessOf(platform: string | undefined): "claude-code" | "cursor" | "codex" {
+  if (platform === "cursor") return "cursor";
+  if (platform === "codex") return "codex";
+  return "claude-code";
+}
+
+/** Assume `target` for one live main session. Safe to retry. */
+export function assumeIdentity(
+  coordRoot: string,
+  instanceId: string,
+  target: string,
+): IdentityAssumeResult {
+  const release = acquireLock(coordRoot);
+  try {
+    const hb = readHeartbeat(coordRoot, instanceId);
+    if (!hb) {
+      throw new IdentityAssumeError(
+        "no_heartbeat",
+        `no live heartbeat for instance '${instanceId}'`,
+      );
+    }
+    if (hb.kind && hb.kind !== "session") {
+      throw new IdentityAssumeError(
+        "not_session",
+        `identity assumption is limited to main sessions (current kind: ${hb.kind})`,
+      );
+    }
+
+    const targetIdentity = resolveTarget(coordRoot, target);
+    let reclaimedInstanceId: string | null = null;
+    let conflict = findIdentityConflict(coordRoot, instanceId, targetIdentity.name);
+    if (conflict && reclaimAbandonedLocalConflict(coordRoot, conflict)) {
+      reclaimedInstanceId = conflict.instance_id;
+      conflict = findIdentityConflict(coordRoot, instanceId, targetIdentity.name);
+    }
+    if (conflict) {
+      const where = conflict.scope === "remote" ? ` on ${conflict.machine}` : "";
+      throw new IdentityAssumeError(
+        "identity_in_use",
+        `agent-${targetIdentity.name} is already live${where} (${conflict.instance_id}); end or stale-sweep that session before assuming the identity`,
+      );
+    }
+    const identity = targetIdentity.identity ?? ensureIdentity(targetIdentity.name, coordRoot);
+    const created = !targetIdentity.identity;
+
+    const previousName = hb.name || null;
+    const previousAgentId = hb.agent_id || null;
+    const history = recordNameAssumption(
+      coordRoot,
+      instanceId,
+      identity.name,
+      identity.agent_id,
+      "session",
+    );
+    const changed =
+      history.changed || previousName !== identity.name || previousAgentId !== identity.agent_id;
+    if (!changed) {
+      return {
+        changed: false,
+        instance_id: instanceId,
+        session_id: hb.session_id,
+        previous_name: previousName,
+        previous_agent_id: previousAgentId,
+        name: identity.name,
+        agent_id: identity.agent_id,
+        identity_created: false,
+        event_id: null,
+        reclaimed_instance_id: reclaimedInstanceId,
+      };
+    }
+
+    const emitted = emitAndProject(
+      {
+        event_type: "identity.assumed",
+        instance_id: instanceId,
+        session_id: hb.session_id,
+        harness: harnessOf(hb.platform),
+        data: {
+          name: identity.name,
+          agent_id: identity.agent_id,
+          ...(previousName ? { previous_name: previousName } : {}),
+          ...(previousAgentId ? { previous_agent_id: previousAgentId } : {}),
+          ...(reclaimedInstanceId ? { reclaimed_instance_id: reclaimedInstanceId } : {}),
+        },
+      },
+      { coordRoot },
+    );
+    if (!emitted?.projected) {
+      throw new IdentityAssumeError(
+        "projection_failed",
+        "the durable name binding was recorded but event projection failed; rerun the command to heal it",
+      );
+    }
+
+    const projected = readHeartbeat(coordRoot, instanceId);
+    if (projected?.name !== identity.name || projected.agent_id !== identity.agent_id) {
+      throw new IdentityAssumeError(
+        "projection_failed",
+        "identity.assumed was emitted but the heartbeat did not converge; rerun the command",
+      );
+    }
+    return {
+      changed: true,
+      instance_id: instanceId,
+      session_id: hb.session_id,
+      previous_name: previousName,
+      previous_agent_id: previousAgentId,
+      name: identity.name,
+      agent_id: identity.agent_id,
+      identity_created: created,
+      event_id: emitted.envelope.event_id,
+      reclaimed_instance_id: reclaimedInstanceId,
+    };
+  } finally {
+    release();
+  }
+}