mirror-mind 0.33.3 → 0.34.0

package/ts/src/runtime/pluginWiring.ts

@@ -0,0 +1,135 @@
+// The plugin wiring readers (CV21.DS4.TS6).
+//
+// Two runtimes hold the plugin outside the install tree. Codex copies it into
+// a versioned cache (`$CODEX_HOME/plugins/cache/mirror-mind/mirror-mind/
+// <version>`; CV21.DS4.US1), so an npm update changes the install but not
+// that copy — the one wiring that goes stale. Claude Code links the plugin in
+// place (`~/.claude/skills/mirror-mind`), so its failure mode is a dangling
+// link, not a stale copy.
+//
+// Both readers take their roots as ARGUMENTS, always. The defaulting —
+// `$CODEX_HOME` else `~/.codex`, and the Claude home — happens once, at the
+// diagnose entry, from the env the caller already carries, never in here.
+// That is the CR123/128/137/142 lesson: a maintainer's machine has a real
+// ~/.codex and a real ~/.claude, and a reader that consults the environment
+// makes every fixture test machine-dependent exactly where maintainers work.
+//
+// Nothing here runs `codex` or mutates anything: Mirror reads directories and
+// prints a command for the person to run. On the installed Codex 0.163.0,
+// `codex plugin` has no update verb (add, list, marketplace, remove), so the
+// level-up command is the re-add — `CODEX_PLUGIN_ADD_COMMAND`, the same
+// constant `mirror init`'s wiring lines print (the CR071 lesson at the
+// string level).
+
+import { lstatSync, readdirSync, readFileSync, readlinkSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { compareSemver, parseSemver } from "#util/semver.ts";
+
+/** Where Codex keeps its copy, below a Codex home. */
+export const CODEX_PLUGIN_CACHE_SEGMENTS: readonly string[] = [
+  "plugins",
+  "cache",
+  "mirror-mind",
+  "mirror-mind",
+];
+
+export interface CodexCacheState {
+  /** `absent` covers no cache and a cache with no version-named entry. */
+  state: "absent" | "current" | "behind" | "ahead";
+  cachePath: string;
+  /** The newest version-named entry, by semver — never a string sort. */
+  newestCached: string | null;
+}
+
+/**
+ * Read the Codex plugin cache below `codexHome`, read-only. Entries whose
+ * names do not parse as versions (a partial download, an editor's leavings)
+ * are ignored; a cache holding only those claims nothing and reads as absent.
+ *
+ * `ahead` is a state, not a finding: `runtime update` refuses downgrades but
+ * `npm install -g mirror-mind@old` does not ask, and the person who
+ * downgraded on purpose needs no Codex advice from the older tree.
+ */
+export function codexPluginCacheState(
+  codexHome: string,
+  installedVersion: string,
+): CodexCacheState {
+  const cachePath = join(codexHome, ...CODEX_PLUGIN_CACHE_SEGMENTS);
+  let entries: string[];
+  try {
+    entries = readdirSync(cachePath);
+  } catch {
+    return { state: "absent", cachePath, newestCached: null };
+  }
+  let newest: string | null = null;
+  for (const entry of entries) {
+    if (parseSemver(entry)[0] < 0) continue;
+    try {
+      if (!statSync(join(cachePath, entry)).isDirectory()) continue;
+    } catch {
+      continue;
+    }
+    if (newest === null || compareSemver(entry, newest) > 0) newest = entry;
+  }
+  if (newest === null) return { state: "absent", cachePath, newestCached: null };
+  const order = compareSemver(newest, installedVersion);
+  const state = order < 0 ? "behind" : order > 0 ? "ahead" : "current";
+  return { state, cachePath, newestCached: newest };
+}
+
+export interface ClaudeLinkState {
+  /** `healthy` means the target reads — including a plain directory copy. */
+  state: "absent" | "healthy" | "dangling";
+  linkPath: string;
+  /** The link's own target when it is a symlink, else null. */
+  target: string | null;
+}
+
+/**
+ * Read the Claude Code wiring below `claudeHome`. Healthy means the target
+ * reads; a link that resolves to *another* install tree is deliberately
+ * healthy too (TS6's documented silence) — chasing where it points is a
+ * one-line amendment here if that case ever bites.
+ */
+export function claudePluginLinkState(claudeHome: string): ClaudeLinkState {
+  const linkPath = join(claudeHome, "skills", "mirror-mind");
+  let isLink = false;
+  try {
+    isLink = lstatSync(linkPath).isSymbolicLink();
+  } catch {
+    return { state: "absent", linkPath, target: null };
+  }
+  const target = isLink ? readlinkSync(linkPath) : null;
+  try {
+    statSync(linkPath);
+  } catch {
+    return { state: "dangling", linkPath, target };
+  }
+  return { state: "healthy", linkPath, target };
+}
+
+/**
+ * The install tree's own plugin version, from the generated manifest.
+ * `plugins/mirror-mind/.claude-plugin/plugin.json` is written by
+ * `claudePlugin.ts` from `packageVersion()`, and the guard holds the
+ * committed manifest equal to the generated one — the file is the authority,
+ * not an assumption. Reading it FROM DISK is also what makes a post-update
+ * hint honest: the process that ran the update is the old version's code,
+ * but the tree it reads has already landed the new one.
+ */
+export function installedPluginVersion(installRoot: string): string | null {
+  try {
+    const raw = readFileSync(
+      join(installRoot, "plugins", "mirror-mind", ".claude-plugin", "plugin.json"),
+      "utf8",
+    );
+    const parsed: unknown = JSON.parse(raw);
+    const version =
+      typeof parsed === "object" && parsed !== null
+        ? (parsed as Record<string, unknown>).version
+        : undefined;
+    return typeof version === "string" && version !== "" ? version : null;
+  } catch {
+    return null;
+  }
+}

package/ts/src/runtime/update.ts

@@ -26,8 +26,10 @@
 // chosen once, below; no step asks which lane it is in.
 
 import { spawnSync } from "node:child_process";
+import { join } from "node:path";
 import { verifyBackupArchive } from "#runtime/backup.ts";
 import type { InstallKind } from "#runtime/installKind.ts";
+import { codexPluginCacheState, installedPluginVersion } from "#runtime/pluginWiring.ts";
 import { cloneStrategy, defaultGitRunner, type GitRunner } from "#runtime/strategies/clone.ts";
 import { defaultNpmRunner, type NpmRunner, packageStrategy } from "#runtime/strategies/package.ts";
 import type { statusAllowsUpdatePreflight } from "#runtime/updateGate.ts";
@@ -37,6 +39,7 @@ import {
   type UpdateResult,
   type UpdateStage,
 } from "#runtime/updatePipeline.ts";
+import { CODEX_PLUGIN_ADD_COMMAND } from "#runtime/wiring.ts";
 import { commandOnPath } from "#util/paths.ts";
 import { PROGRAM } from "#util/program.ts";
 import { shellWord } from "#util/shellWord.ts";
@@ -405,12 +408,42 @@ export function postUpdateHints(
   env: NodeJS.ProcessEnv,
   canExecute?: (path: string) => boolean,
 ): string[] {
-  if (install.kind !== "clone" || !result.success) return [];
-  if (commandOnPath(PROGRAM, env, canExecute) !== null) return [];
-  // A command the person will paste: the path is one shell word (CR104).
-  return [
-    `\`${PROGRAM}\` is not on the PATH: run \`npm link\` once in ${shellWord(install.repository)}, so the skills can call it.`,
-  ];
+  if (!result.success) return [];
+  const hints: string[] = [];
+
+  if (install.kind === "clone" && commandOnPath(PROGRAM, env, canExecute) === null) {
+    // A command the person will paste: the path is one shell word (CR104).
+    hints.push(
+      `\`${PROGRAM}\` is not on the PATH: run \`npm link\` once in ${shellWord(install.repository)}, so the skills can call it.`,
+    );
+  }
+
+  // CV21.DS4.TS6: Codex runs the plugin copy it cached at install, so the
+  // update that just landed did not reach it. The version authority is the
+  // LANDED version, read from the just-updated tree's plugin.json -- this
+  // process is the old version's code, and its own constant would read a
+  // just-staled cache as current.
+  const installRoot =
+    install.kind === "clone"
+      ? install.repository
+      : install.kind === "package"
+        ? install.root
+        : null;
+  const home = env.HOME?.trim() || null;
+  const codexHome = env.CODEX_HOME?.trim() || (home ? join(home, ".codex") : null);
+  if (installRoot && codexHome) {
+    const landed = installedPluginVersion(installRoot);
+    if (landed) {
+      const cache = codexPluginCacheState(codexHome, landed);
+      if (cache.state === "behind") {
+        hints.push(
+          `Codex's cached plugin is behind the update (${cache.newestCached} < ${landed}): run \`${CODEX_PLUGIN_ADD_COMMAND}\` to bring it level.`,
+        );
+      }
+    }
+  }
+
+  return hints;
 }
 
 function firstLine(text: string): string {

package/ts/src/runtime/wiring.ts

@@ -23,17 +23,31 @@
 //               and hooks live in `~/.gemini/settings.json`, absolute paths.
 //               Two steps. The Operating Instructions arrive through the
 //               SessionStart hook (D13).
-//   Codex       `~/.codex/skills/<dir>` is discovered recursively, and
-//               `~/.codex/AGENTS.md` is the global instructions file
-//               (`codex debug prompt-input`, 0.157.0). Two steps, and the
-//               session is run through the shipped wrapper, since Codex has
-//               no hooks this integration uses.
+//   Codex       `codex plugin marketplace add <root>` reads the package's
+//               `.agents/plugins/marketplace.json`, and `codex plugin add
+//               mirror-mind@mirror-mind` copies the plugin into Codex's cache
+//               with its skills, hooks, and MCP server (0.162.1, CV21.DS12.TS2
+//               static 5-7; CV21.DS4.US1). Two steps. Codex asks once, at the
+//               next session, to trust the plugin's hooks (L1); the Operating
+//               Instructions then arrive through its SessionStart hook as a
+//               developer message (L4). Until DS4.US1 the two steps were a
+//               skills link and an AGENTS.md link, with sessions run through
+//               the shipped wrapper.
 
 import { join } from "node:path";
 import { commandOnPath } from "#util/paths.ts";
 
 export type RuntimeName = "pi" | "claude" | "gemini" | "codex";
 
+/**
+ * The one Codex level-up command (CV21.DS4.TS6). Codex 0.163.0 has no
+ * plugin-update verb, so re-adding is how a cached plugin reaches the
+ * installed version. One constant so the wiring line `mirror init` prints
+ * and the recommendation `runtime diagnose` prints cannot disagree (the
+ * CR071 lesson at the string level).
+ */
+export const CODEX_PLUGIN_ADD_COMMAND = "codex plugin add mirror-mind@mirror-mind";
+
 export interface RuntimeWiring {
   /** The runtime, as a person names it. */
   readonly title: string;
@@ -94,11 +108,11 @@ export const RUNTIME_WIRING: Readonly<Record<RuntimeName, RuntimeWiring>> = {
     title: "Codex",
     command: "codex",
     steps: [
-      (root) => [`ln -s "${join(root, ".pi/skills")}" ~/.codex/skills/mirror-mind`],
-      (root) => [
-        `ln -s "${join(root, "AGENTS.md")}" ~/.codex/AGENTS.md`,
-        "(or append that file to the ~/.codex/AGENTS.md you already have)",
-        `then start Codex through "${join(root, "scripts/codex-mirror.sh")}" instead of codex`,
+      (root) => [`codex plugin marketplace add "${root}"`],
+      () => [
+        CODEX_PLUGIN_ADD_COMMAND,
+        "(Codex asks once, at the next session, to trust the plugin's hooks; the plugin",
+        "then loads every session: its skills, the hooks, and the MCP server)",
       ],
     ],
   },

package/scripts/codex-hooks/session-end.sh

@@ -1,85 +0,0 @@
-#!/usr/bin/env bash
-# Mirror Mind hook wrapper — GENERATED by scripts/generate_hook_wrappers.sh.
-# Edit the generator, never this file: every wrapper shares these bytes and
-# differs only in the hook name and in how it finds the Mirror entry
-# (CV22.DS10.TS5 decision D4; CV22.DS10.US3 decision D5).
-set -uo pipefail
-HOOK="codex:session-end"
-
-# Resolve the tree from THIS FILE, never from the cwd: a runtime spawns hooks
-# from whatever directory the session is in. The tree is a checkout or the
-# installed package; the wrapper's depth to its root is the same in both.
-HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd -P)"
-REPO_ROOT="$(cd "$HERE/../.." && pwd -P)"
-
-# A hook never fails the user's turn, and never fails in silence: when it
-# cannot do its job it appends ONE line to <mirror home>/hooks.log and exits 0.
-# The home is found the way the core finds it -- MIRROR_HOME, else
-# MIRROR_USER -- from the environment when set there, else from the tree's
-# .env when the wrapper is in a tree, else from the user's config file
-# (~/.config/mirror/env), in the core's order (US3, D3). A GUI launch carries
-# neither variable, and the first wrappers then wrote to a home nobody reads.
-env_file_value() {
-  [ -f "$2" ] || return 0
-  sed -n -E "s/^[[:space:]]*(export[[:space:]]+)?$1[[:space:]]*=[[:space:]]*//p" "$2" \
-    | tail -n 1 | tr -d "\"'\r"
-}
-env_value() {
-  local value=""
-  if [ -n "${!1+set}" ]; then printf '%s' "${!1}"; return; fi
-  [ -z "$REPO_ROOT" ] || value="$(env_file_value "$1" "$REPO_ROOT/.env")"
-  [ -n "$value" ] || value="$(env_file_value "$1" "${XDG_CONFIG_HOME:-$HOME/.config}/mirror/env")"
-  printf '%s' "$value"
-}
-note() {
-  local home user
-  home="$(env_value MIRROR_HOME)"
-  user="$(env_value MIRROR_USER)"
-  if [ -n "$home" ]; then
-    home="${home/#\~/$HOME}"
-  elif [ -n "$user" ]; then
-    home="$HOME/.mirror-minds/$user"
-    [ -d "$home" ] || [ ! -d "$HOME/.mirror/$user" ] || home="$HOME/.mirror/$user"
-  else
-    return 0
-  fi
-  mkdir -p "$home" 2>/dev/null \
-    && printf '%s %s: %s\n' "$(date -u +%Y-%m-%dT%H:%M:%SZ)" "$HOOK" "$1" >> "$home/hooks.log" 2>/dev/null
-}
-
-ENTRY="$REPO_ROOT/bin/mirror-hook.js"
-
-# Find Node. /usr/bin/python3 exists on every macOS; node usually lives under
-# nvm or Homebrew and is NOT on the PATH of a GUI-launched runtime. The Python
-# hooks could end in `|| true` because they always found their interpreter;
-# the same silence here would hide a new failure — no logging, no inject, no
-# close tail — that a user would meet weeks later as "Mirror stopped
-# remembering". So an unresolvable Node is RECORDED, never swallowed. The
-# directory the entry was found in is searched first: an npm global bin holds
-# the `node` that installed the package beside `mirror-hook`, while a system
-# `/usr/local/bin/node` can be years older (CI's Ubuntu runner has one).
-NODE="${MIRROR_NODE:-}"
-if [ -z "$NODE" ] || [ ! -x "$NODE" ]; then
-  NODE="$(command -v node 2>/dev/null || true)"
-fi
-for candidate in "$(dirname "$ENTRY")/node" "$HOME/.nvm/current/bin/node" /opt/homebrew/bin/node /usr/local/bin/node; do
-  [ -n "$NODE" ] && break
-  [ -x "$candidate" ] && NODE="$candidate"
-done
-
-if [ -z "$NODE" ]; then
-  note "node not found on PATH; hook skipped. Set MIRROR_NODE."
-  exit 0
-fi
-
-# Not `exec`: the entry exits 0 whatever happens inside it, so a non-zero exit
-# means Node itself could not run the hook -- too old for the loader shim, or
-# it crashed. That used to vanish into a stderr no runtime shows (TS5 handoff
-# review, finding N1). No flags: the entry reads configuration and silences
-# its own warnings (US3, D3).
-"$NODE" "$ENTRY" "$HOOK" "$@"
-status=$?
-if [ "$status" -ne 0 ]; then
-  note "node exited $status before the hook finished ($NODE, $("$NODE" --version 2>/dev/null || echo 'version unknown')); Mirror needs Node 24 or later. Set MIRROR_NODE."
-fi
-exit 0

package/scripts/codex-hooks/session-start.sh

@@ -1,85 +0,0 @@
-#!/usr/bin/env bash
-# Mirror Mind hook wrapper — GENERATED by scripts/generate_hook_wrappers.sh.
-# Edit the generator, never this file: every wrapper shares these bytes and
-# differs only in the hook name and in how it finds the Mirror entry
-# (CV22.DS10.TS5 decision D4; CV22.DS10.US3 decision D5).
-set -uo pipefail
-HOOK="codex:session-start"
-
-# Resolve the tree from THIS FILE, never from the cwd: a runtime spawns hooks
-# from whatever directory the session is in. The tree is a checkout or the
-# installed package; the wrapper's depth to its root is the same in both.
-HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd -P)"
-REPO_ROOT="$(cd "$HERE/../.." && pwd -P)"
-
-# A hook never fails the user's turn, and never fails in silence: when it
-# cannot do its job it appends ONE line to <mirror home>/hooks.log and exits 0.
-# The home is found the way the core finds it -- MIRROR_HOME, else
-# MIRROR_USER -- from the environment when set there, else from the tree's
-# .env when the wrapper is in a tree, else from the user's config file
-# (~/.config/mirror/env), in the core's order (US3, D3). A GUI launch carries
-# neither variable, and the first wrappers then wrote to a home nobody reads.
-env_file_value() {
-  [ -f "$2" ] || return 0
-  sed -n -E "s/^[[:space:]]*(export[[:space:]]+)?$1[[:space:]]*=[[:space:]]*//p" "$2" \
-    | tail -n 1 | tr -d "\"'\r"
-}
-env_value() {
-  local value=""
-  if [ -n "${!1+set}" ]; then printf '%s' "${!1}"; return; fi
-  [ -z "$REPO_ROOT" ] || value="$(env_file_value "$1" "$REPO_ROOT/.env")"
-  [ -n "$value" ] || value="$(env_file_value "$1" "${XDG_CONFIG_HOME:-$HOME/.config}/mirror/env")"
-  printf '%s' "$value"
-}
-note() {
-  local home user
-  home="$(env_value MIRROR_HOME)"
-  user="$(env_value MIRROR_USER)"
-  if [ -n "$home" ]; then
-    home="${home/#\~/$HOME}"
-  elif [ -n "$user" ]; then
-    home="$HOME/.mirror-minds/$user"
-    [ -d "$home" ] || [ ! -d "$HOME/.mirror/$user" ] || home="$HOME/.mirror/$user"
-  else
-    return 0
-  fi
-  mkdir -p "$home" 2>/dev/null \
-    && printf '%s %s: %s\n' "$(date -u +%Y-%m-%dT%H:%M:%SZ)" "$HOOK" "$1" >> "$home/hooks.log" 2>/dev/null
-}
-
-ENTRY="$REPO_ROOT/bin/mirror-hook.js"
-
-# Find Node. /usr/bin/python3 exists on every macOS; node usually lives under
-# nvm or Homebrew and is NOT on the PATH of a GUI-launched runtime. The Python
-# hooks could end in `|| true` because they always found their interpreter;
-# the same silence here would hide a new failure — no logging, no inject, no
-# close tail — that a user would meet weeks later as "Mirror stopped
-# remembering". So an unresolvable Node is RECORDED, never swallowed. The
-# directory the entry was found in is searched first: an npm global bin holds
-# the `node` that installed the package beside `mirror-hook`, while a system
-# `/usr/local/bin/node` can be years older (CI's Ubuntu runner has one).
-NODE="${MIRROR_NODE:-}"
-if [ -z "$NODE" ] || [ ! -x "$NODE" ]; then
-  NODE="$(command -v node 2>/dev/null || true)"
-fi
-for candidate in "$(dirname "$ENTRY")/node" "$HOME/.nvm/current/bin/node" /opt/homebrew/bin/node /usr/local/bin/node; do
-  [ -n "$NODE" ] && break
-  [ -x "$candidate" ] && NODE="$candidate"
-done
-
-if [ -z "$NODE" ]; then
-  note "node not found on PATH; hook skipped. Set MIRROR_NODE."
-  exit 0
-fi
-
-# Not `exec`: the entry exits 0 whatever happens inside it, so a non-zero exit
-# means Node itself could not run the hook -- too old for the loader shim, or
-# it crashed. That used to vanish into a stderr no runtime shows (TS5 handoff
-# review, finding N1). No flags: the entry reads configuration and silences
-# its own warnings (US3, D3).
-"$NODE" "$ENTRY" "$HOOK" "$@"
-status=$?
-if [ "$status" -ne 0 ]; then
-  note "node exited $status before the hook finished ($NODE, $("$NODE" --version 2>/dev/null || echo 'version unknown')); Mirror needs Node 24 or later. Set MIRROR_NODE."
-fi
-exit 0

package/scripts/codex-mirror.sh

@@ -1,48 +0,0 @@
-#!/usr/bin/env bash
-# Run Codex with Mirror Mind logging around it.
-#
-# Codex has no hook system, so this wraps the `codex` command: session start
-# before it, and after it the JSONL Codex wrote is imported, the session is
-# closed, and a silent backup is taken.
-#
-# Every Mirror call goes through a generated hook wrapper under
-# scripts/codex-hooks/, the way every other runtime's hooks do (CV22.DS10.TS5
-# handoff review, finding N3). The wrappers resolve Node explicitly, never fail
-# the session, and record anything they could not do in <mirror home>/hooks.log.
-# This script used to call the front door itself, as a command held in a string
-# that a checkout path with a space split in two -- silently.
-set -euo pipefail
-
-HOOKS="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd -P)/codex-hooks"
-
-# The marker's mtime is how the session this run wrote is told from older ones.
-MARKER="$(mktemp)"
-trap 'rm -f "$MARKER"' EXIT
-
-cd "${CODEX_PROJECT_DIR:-$PWD}"
-
-# 1. Session start.
-bash "$HOOKS/session-start.sh" </dev/null >/dev/null 2>&1 || true
-
-# 2. Codex itself, until the user exits. `set -e` is off around it so the
-# wrap-up below still runs when Codex exits non-zero -- after an MCP startup
-# failure, for example -- and its exit code is still the script's.
-set +e
-codex "$@"
-EXIT_CODE=$?
-set -e
-
-# 3. The JSONL Codex wrote after the marker for this directory, if any:
-# ~/.codex/sessions/YYYY/MM/DD/rollout-<time>-<uuid>.jsonl.
-SESSION_JSONL="$(find ~/.codex/sessions -name "*.jsonl" -newer "$MARKER" \
-  -exec grep -l "\"cwd\":\"$PWD\"" {} + 2>/dev/null | sort | tail -1 || true)"
-SESSION_ID=""
-if [[ -n "$SESSION_JSONL" ]]; then
-  SESSION_ID="$(basename "$SESSION_JSONL" .jsonl \
-    | grep -oE '[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}' | tail -1 || true)"
-fi
-
-# 4. Import and close the session when there is one, then the silent backup.
-bash "$HOOKS/session-end.sh" "$SESSION_JSONL" "$SESSION_ID" </dev/null >/dev/null 2>&1 || true
-
-exit "$EXIT_CODE"

package/ts/src/hooks/codex.ts

@@ -1,45 +0,0 @@
-// Codex hook entries (CV22.DS10.TS5 handoff review, finding N3).
-//
-// Codex has no hook system, so `scripts/codex-mirror.sh` wraps the `codex`
-// command itself and calls these through two generated wrappers under
-// `scripts/codex-hooks/`. Until the handoff review the script called the front
-// door directly: it found `node` on PATH alone, silenced every failure, and
-// built its command as a string that a checkout path with a space split in
-// two. Going through the wrappers gives it the same Node resolution and the
-// same hooks.log record as every other runtime.
-//
-// The payload comes as arguments, not stdin: the wrapper, not a runtime,
-// decides what to pass, and a path is safer as one quoted argument than
-// embedded in hand-written JSON.
-
-import { runFrontDoorQuietly } from "./runtime.ts";
-
-/** Wrapper start: make sure logging is on for this session. */
-export async function codexSessionStart(): Promise<number> {
-  await runFrontDoorQuietly("codex:session-start", ["conversation-logger", "session-start"]);
-  return 0;
-}
-
-/**
- * Wrapper exit: import the session Codex wrote, close it, then take the silent
- * backup. The transcript and its session id are both absent when Codex wrote
- * no session for this directory; the backup runs either way, as it always has.
- */
-export async function codexSessionEnd(transcriptPath: string, sessionId: string): Promise<number> {
-  if (transcriptPath && sessionId) {
-    await runFrontDoorQuietly("codex:session-end", [
-      "conversation-logger",
-      "backfill-codex-session",
-      transcriptPath,
-      "--interface",
-      "codex",
-    ]);
-    await runFrontDoorQuietly("codex:session-end", [
-      "conversation-logger",
-      "session-end-pi",
-      sessionId,
-    ]);
-  }
-  await runFrontDoorQuietly("codex:session-end", ["backup", "--silent"]);
-  return 0;
-}