opencode-memory

#!/usr/bin/env bash
#
# opencode-memory — Wrapper for OpenCode with post-session memory maintenance.
#
# Installs a shell hook (function) that intercepts the `opencode` command,
# then wraps the real binary with post-session extraction and auto-dream.
#
# Subcommands:
#   opencode-memory install    — Install shell hook to ~/.zshrc or ~/.bashrc
#   opencode-memory uninstall  — Remove shell hook
#   opencode-memory self -v    — Print the wrapper package version
#   opencode-memory [args...]  — Run opencode with post-session memory maintenance
#
# How it works:
#   1. Shell hook defines `opencode()` function that delegates to `opencode-memory`
#   2. `opencode-memory` finds the real `opencode` binary in PATH
#   3. Runs it normally with all your arguments
#   4. After you exit, finds the most recent session
#   5. Optionally runs memory extraction (conversation -> memories)
#   6. Optionally runs auto-dream consolidation (memory pruning/merge)
#
# Requirements:
#   - Real `opencode` CLI reachable in PATH
#   - `jq` for auto-dream gate/session counting
#   - The opencode-memory plugin installed (provides memory_* tools)
#
# Environment variables:
#   OPENCODE_MEMORY_EXTRACT=0                 — Disable post-session extraction
#   OPENCODE_MEMORY_FOREGROUND=1              — Run maintenance in foreground (debug)
#   OPENCODE_MEMORY_TERMINAL_LOG=1|0          — Force-enable/disable terminal logs (default: foreground only)
#   OPENCODE_MEMORY_MODEL=...                 — Extraction model override
#   OPENCODE_MEMORY_AGENT=...                 — Extraction agent override
#   OPENCODE_MEMORY_AUTODREAM=0               — Disable auto-dream consolidation
#   OPENCODE_MEMORY_AUTODREAM_MIN_HOURS=24    — Min hours between auto-dream runs
#   OPENCODE_MEMORY_AUTODREAM_MIN_SESSIONS=5  — Min touched sessions since last consolidation
#   OPENCODE_MEMORY_AUTODREAM_MODEL=...       — Auto-dream model override
#   OPENCODE_MEMORY_AUTODREAM_AGENT=...       — Auto-dream agent override
#   OPENCODE_MEMORY_DIR=...                   — Override working directory for opencode
#

set -euo pipefail

resolve_script_path() {
  if command -v python3 >/dev/null 2>&1; then
    python3 - "${BASH_SOURCE[0]}" <<'PY'
import os
import sys

print(os.path.realpath(sys.argv[1]))
PY
    return 0
  fi

  printf '%s\n' "${BASH_SOURCE[0]}"
}

SCRIPT_PATH="$(resolve_script_path)"
SCRIPT_DIR="$(CDPATH= cd -- "$(dirname -- "$SCRIPT_PATH")" && pwd)"
PACKAGE_JSON="$SCRIPT_DIR/../package.json"

resolve_package_json() {
  if [ -f "$PACKAGE_JSON" ]; then
    printf '%s\n' "$PACKAGE_JSON"
    return 0
  fi

  if command -v npm >/dev/null 2>&1; then
    local npm_root
    npm_root=$(npm root -g 2>/dev/null || true)
    if [ -n "$npm_root" ] && [ -f "$npm_root/opencode-claude-memory/package.json" ]; then
      printf '%s\n' "$npm_root/opencode-claude-memory/package.json"
      return 0
    fi
  fi

  printf '%s\n' "$PACKAGE_JSON"
}

print_wrapper_version() {
  local version
  local package_json

  package_json="$(resolve_package_json)"

  version=$(awk -F'"' '/^[[:space:]]*"version"[[:space:]]*:/ { print $4; exit }' "$package_json")

  if [ -z "$version" ]; then
    echo "[opencode-memory] ERROR: Cannot read package version from $package_json" >&2
    exit 1
  fi

  printf '%s\n' "$version"
}

# ============================================================================
# Shell Hook Management
# ============================================================================

HOOK_START_MARKER='# >>> opencode-memory auto-initialization >>>'
HOOK_END_MARKER='# <<< opencode-memory auto-initialization <<<'

detect_shell_rc() {
  local shell_name
  shell_name="$(basename "${SHELL:-}")"

  case "$shell_name" in
    zsh)
      echo "$HOME/.zshrc"
      ;;
    bash)
      echo "$HOME/.bashrc"
      ;;
    *)
      if [ -f "$HOME/.zshrc" ]; then
        echo "$HOME/.zshrc"
      elif [ -f "$HOME/.bashrc" ]; then
        echo "$HOME/.bashrc"
      else
        echo "$HOME/.zshrc"
      fi
      ;;
  esac
}

install_hook() {
  local rc_file
  rc_file=$(detect_shell_rc)

  if grep -qF "$HOOK_START_MARKER" "$rc_file" 2>/dev/null; then
    echo "[opencode-memory] Hook already installed in $rc_file"
    return 0
  fi

  cat >> "$rc_file" << 'HOOK'

# >>> opencode-memory auto-initialization >>>
opencode() {
  command opencode-memory "$@"
}
# <<< opencode-memory auto-initialization <<<
HOOK

  echo "[opencode-memory] Shell hook installed in $rc_file"
  echo "[opencode-memory] Restart your shell or run: source $rc_file"
}

remove_hook_from_rc() {
  local rc_file="$1"
  local tmp_file
  tmp_file=$(mktemp)

  awk -v start="$HOOK_START_MARKER" -v end="$HOOK_END_MARKER" '
    $0 == start { skip=1; next }
    $0 == end   { skip=0; next }
    !skip
  ' "$rc_file" > "$tmp_file"

  mv "$tmp_file" "$rc_file"
}

uninstall_hook() {
  local removed=0
  local rc_file

  for rc_file in "$HOME/.zshrc" "$HOME/.bashrc"; do
    [ -f "$rc_file" ] || continue

    if grep -qF "$HOOK_START_MARKER" "$rc_file" 2>/dev/null; then
      remove_hook_from_rc "$rc_file"
      echo "[opencode-memory] Shell hook removed from $rc_file"
      removed=1
    fi
  done

  if [ "$removed" -eq 0 ]; then
    rc_file=$(detect_shell_rc)
    echo "[opencode-memory] Hook not found in $rc_file"
    return 0
  fi

  echo "[opencode-memory] Restart your shell or run: source <your rc file>"
}

# Handle subcommands before any opencode resolution
case "${1:-}" in
  install)
    install_hook
    exit 0
    ;;
  uninstall)
    uninstall_hook
    exit 0
    ;;
  self)
    case "${2:-}" in
      -v|--version|version)
        print_wrapper_version
        exit 0
        ;;
    esac
    ;;
esac

# ============================================================================
# Resolve the real opencode binary
# ============================================================================

find_real_opencode() {
  # Since this script is named `opencode-memory` (not `opencode`),
  # `command -v opencode` finds the real binary without ambiguity.
  local real
  real=$(command -v opencode 2>/dev/null) || true
  if [ -z "$real" ] || [ ! -x "$real" ]; then
    echo "[opencode-memory] ERROR: Cannot find opencode binary in PATH" >&2
    echo "[opencode-memory] Make sure opencode is installed: https://opencode.ai" >&2
    exit 1
  fi
  echo "$real"
}

REAL_OPENCODE="$(find_real_opencode)"

is_opencode_subcommand() {
  case "$1" in
    completion|acp|mcp|attach|run|debug|providers|auth|agent|upgrade|uninstall|serve|web|models|stats|export|import|github|pr|session|plugin|plug|db)
      return 0
      ;;
    *)
      return 1
      ;;
  esac
}

extract_working_dir_from_args() {
  local previous=""
  for arg in "$@"; do
    if [ "$previous" = "--dir" ]; then
      printf '%s\n' "$arg"
      return 0
    fi
    previous="$arg"
  done

  if [ "$#" -gt 0 ] && [ -n "${1:-}" ] && [[ "${1:-}" != -* ]] && ! is_opencode_subcommand "$1" && [ -d "$1" ]; then
    printf '%s\n' "$1"
    return 0
  fi

  return 1
}

# ============================================================================
# Configuration
# ============================================================================

EXTRACT_ENABLED="${OPENCODE_MEMORY_EXTRACT:-1}"
FOREGROUND="${OPENCODE_MEMORY_FOREGROUND:-0}"
LOG_ENABLED="${OPENCODE_MEMORY_TERMINAL_LOG:-}"
EXTRACT_MODEL="${OPENCODE_MEMORY_MODEL:-}"
EXTRACT_AGENT="${OPENCODE_MEMORY_AGENT:-}"

AUTODREAM_ENABLED="${OPENCODE_MEMORY_AUTODREAM:-1}"
AUTODREAM_MIN_HOURS="${OPENCODE_MEMORY_AUTODREAM_MIN_HOURS:-24}"
AUTODREAM_MIN_SESSIONS="${OPENCODE_MEMORY_AUTODREAM_MIN_SESSIONS:-5}"
AUTODREAM_SCAN_LIMIT="${OPENCODE_MEMORY_AUTODREAM_SCAN_LIMIT:-200}"
AUTODREAM_MODEL="${OPENCODE_MEMORY_AUTODREAM_MODEL:-$EXTRACT_MODEL}"
AUTODREAM_AGENT="${OPENCODE_MEMORY_AUTODREAM_AGENT:-$EXTRACT_AGENT}"
AUTODREAM_STALE_LOCK_SECS=$((60 * 60))
SESSION_WAIT_SECONDS="${OPENCODE_MEMORY_SESSION_WAIT_SECONDS:-5}"

WORKING_DIR="${OPENCODE_MEMORY_DIR:-$(extract_working_dir_from_args "$@" || pwd)}"

TMP_BASE_DIR="${TMPDIR:-/tmp}"
while [ "$TMP_BASE_DIR" != "/" ] && [ "${TMP_BASE_DIR%/}" != "$TMP_BASE_DIR" ]; do
  TMP_BASE_DIR="${TMP_BASE_DIR%/}"
done
if [ -z "$TMP_BASE_DIR" ]; then
  TMP_BASE_DIR="/"
fi

# Scope lock files at project root granularity (not per-subdirectory).
PROJECT_SCOPE_DIR="$WORKING_DIR"
if git -C "$WORKING_DIR" rev-parse --show-toplevel >/dev/null 2>&1; then
  PROJECT_SCOPE_DIR="$(git -C "$WORKING_DIR" rev-parse --show-toplevel 2>/dev/null || echo "$WORKING_DIR")"
fi

PROJECT_KEY="$(printf '%s' "$PROJECT_SCOPE_DIR" | cksum | awk '{print $1}')"

# Lock files (prevent concurrent work on the same project)
LOCK_DIR="$TMP_BASE_DIR/opencode-memory-locks"
mkdir -p "$LOCK_DIR"
EXTRACT_LOCK_FILE="$LOCK_DIR/${PROJECT_KEY}.extract.lock"

STATE_DIR="${CLAUDE_CONFIG_DIR:-$HOME/.claude}/opencode-memory"
mkdir -p "$STATE_DIR"
CONSOLIDATION_LOCK_FILE="$STATE_DIR/${PROJECT_KEY}.consolidate-lock"

# Logs
LOG_DIR="$TMP_BASE_DIR/opencode-memory-logs"
mkdir -p "$LOG_DIR"
TASK_LOG_PREFIX="$(date +%Y%m%d-%H%M%S)-${PROJECT_KEY}"
EXTRACT_LOG_FILE="$LOG_DIR/extract-${TASK_LOG_PREFIX}.log"
AUTODREAM_LOG_FILE="$LOG_DIR/dream-${TASK_LOG_PREFIX}.log"

# ============================================================================
# Prompts
# ============================================================================

# Adapted from Claude Code's extraction prompt, simplified for OpenCode's
# headless run mode. The model sees the full conversation context via --fork.
EXTRACT_PROMPT='You are now acting as the memory extraction subagent. Review the entire conversation above and extract any information worth remembering for future sessions.

## What to save

Use the `memory_save` tool to persist memories. There are four types:

1. **user** — Who the user is: role, expertise, preferences, communication style. Helps tailor future interactions.
2. **feedback** — Guidance on how to work: corrections ("don'\''t do X"), confirmations ("yes, keep doing that"), approach preferences. Include *why* so edge cases can be judged.
3. **project** — Ongoing work context: goals, deadlines, initiatives, decisions, bugs. NOT derivable from code/git. Convert relative dates to absolute.
4. **reference** — Pointers to external resources: URLs, tool names, where to find information outside the codebase.

## What NOT to save

- Code patterns, architecture, file structure — derivable from the codebase
- Git history, recent changes — use `git log`/`git blame`
- Debugging solutions — the fix is in the code
- Anything already in AGENTS.md / project config files
- Ephemeral task details or current conversation context
- Information that was already saved in a previous extraction

## How to save

For each memory worth saving, call `memory_save` with:
- `file_name`: descriptive slug (e.g., `user_role`, `feedback_testing_approach`)
- `name`: short title
- `description`: one-line description (used for relevance matching in future sessions)
- `type`: one of user, feedback, project, reference
- `content`: the memory content. For feedback/project types, structure as: rule/fact, then **Why:** and **How to apply:** lines.

## Instructions

1. Analyze the conversation for memorable information
2. Check existing memories first (use `memory_list`) to avoid duplicates — update existing ones if needed
3. Save each distinct memory as a separate entry
4. If the conversation was trivial (e.g., just "hello" or a quick lookup), save nothing — that'\''s fine
5. Be selective: 0-3 memories per session is typical. Quality over quantity.
6. Do NOT save a memory about the extraction process itself.'

# Periodic memory consolidation inspired by Claude Code auto-dream.
AUTODREAM_PROMPT="$(cat <<'EOF'
You are performing an auto-dream memory consolidation pass.

Goal: tighten and de-duplicate memory files so future sessions can orient faster.

## Available tools
- memory_list
- memory_search
- memory_read
- memory_save
- memory_delete

## Phase 1 — Orient
1. Use memory_list to inspect current memory inventory.
2. Identify overlapping or stale entries that can be merged/updated/deleted.

## Phase 2 — Consolidate
1. Merge duplicates into a single stronger memory using memory_save.
2. Rewrite vague descriptions so retrieval is easier and more precise.
3. For feedback/project entries, ensure content is structured as:
   - main rule/fact
   - **Why:**
   - **How to apply:**

## Phase 3 — Prune
1. Delete memories that are clearly obsolete, contradictory, or low-value.
2. Keep total memory set concise and high signal.

## Guardrails
- Do NOT invent facts.
- If confidence is low, keep existing memory instead of guessing.
- If memory quality is already strong, make no changes and explicitly say so.

Return a short summary of what you updated, merged, or removed.
EOF
)"

# ============================================================================
# Helper Functions
# ============================================================================

should_log() {
  if [ -n "$LOG_ENABLED" ]; then
    [ "$LOG_ENABLED" = "1" ]
    return $?
  fi

  [ "$FOREGROUND" = "1" ]
}

log() {
  should_log || return 0
  echo "[opencode-memory] $*" >&2
}

is_positive_int() {
  [[ "$1" =~ ^[0-9]+$ ]] && [ "$1" -gt 0 ]
}

is_bool_flag() {
  [ "$1" = "0" ] || [ "$1" = "1" ]
}

if [ -n "$LOG_ENABLED" ] && ! is_bool_flag "$LOG_ENABLED"; then
  echo "[opencode-memory] Invalid OPENCODE_MEMORY_TERMINAL_LOG=$LOG_ENABLED, expected 0 or 1; defaulting to foreground-only logging" >&2
  LOG_ENABLED=""
fi

if ! is_positive_int "$AUTODREAM_MIN_HOURS"; then
  log "Invalid OPENCODE_MEMORY_AUTODREAM_MIN_HOURS=$AUTODREAM_MIN_HOURS, using default 24"
  AUTODREAM_MIN_HOURS=24
fi
if ! is_positive_int "$AUTODREAM_MIN_SESSIONS"; then
  log "Invalid OPENCODE_MEMORY_AUTODREAM_MIN_SESSIONS=$AUTODREAM_MIN_SESSIONS, using default 5"
  AUTODREAM_MIN_SESSIONS=5
fi
if ! is_positive_int "$AUTODREAM_SCAN_LIMIT"; then
  log "Invalid OPENCODE_MEMORY_AUTODREAM_SCAN_LIMIT=$AUTODREAM_SCAN_LIMIT, using default 200"
  AUTODREAM_SCAN_LIMIT=200
fi

has_new_memories() {
  # Check if any memory file was modified during the session.
  local mem_base="${CLAUDE_CONFIG_DIR:-$HOME/.claude}/projects"
  if [ ! -d "$mem_base" ]; then
    return 1
  fi

  local newer_files
  newer_files=$(find "$mem_base" -path "*/memory/*.md" -newer "$TIMESTAMP_FILE" 2>/dev/null | head -1)
  [ -n "$newer_files" ]
}

cleanup_timestamp() {
  rm -f "$TIMESTAMP_FILE" "${TRANSCRIPT_CHECKPOINT_FILE:-}"
}

get_session_list_json() {
  local limit="$1"
  local output

  if output=$("$REAL_OPENCODE" session list --format json -n "$limit" 2>/dev/null); then
    echo "$output"
    return 0
  fi

  if output=$("$REAL_OPENCODE" session list --format json 2>/dev/null); then
    echo "$output"
    return 0
  fi

  return 1
}

get_latest_session_id() {
  local session_json
  session_json=$(get_session_list_json 1) || return 1

  # Parse with jq if available, fallback to grep.
  if command -v jq &>/dev/null; then
    echo "$session_json" | jq -r '.[0].id // empty'
  else
    echo "$session_json" | grep -o '"id"[[:space:]]*:[[:space:]]*"[^"]*"' | head -1 | sed 's/.*"id"[[:space:]]*:[[:space:]]*"\([^"]*\)"/\1/'
  fi
}

get_opencode_db_path() {
  printf '%s\n' "$HOME/.local/share/opencode/opencode.db"
}

get_session_title_from_db() {
  local session_id="$1"
  local db_path
  db_path=$(get_opencode_db_path)

  if [ -z "$session_id" ] || [ ! -f "$db_path" ] || ! command -v python3 >/dev/null 2>&1; then
    return 1
  fi

  python3 - "$db_path" "$session_id" <<'PY'
import sqlite3
import sys

db_path, session_id = sys.argv[1:3]

try:
    conn = sqlite3.connect(f"file:{db_path}?mode=ro", uri=True)
    row = conn.execute("SELECT title FROM session WHERE id = ? LIMIT 1", (session_id,)).fetchone()
except Exception:
    raise SystemExit(1)
finally:
    try:
        conn.close()
    except Exception:
        pass

if row and row[0]:
    print(row[0])
PY
}

get_session_target_id() {
  local before_json="$1"
  local started_at_ms="$2"
  local workdir="$3"
  local project_dir="$4"
  local allow_existing_fallback="${5:-1}"
  local after_json

  after_json=$(get_session_list_json "$AUTODREAM_SCAN_LIMIT") || return 1

  if command -v python3 >/dev/null 2>&1; then
    python3 - "$before_json" "$after_json" "$started_at_ms" "$workdir" "$project_dir" "$allow_existing_fallback" <<'PY'
import json
import os
import sys

before_raw, after_raw, started_at_ms_raw, workdir, project_dir, allow_existing_fallback_raw = sys.argv[1:7]

def parse(raw):
    try:
        data = json.loads(raw)
        return data if isinstance(data, list) else []
    except Exception:
        return []

def timestamp(item):
    time_obj = item.get("time") if isinstance(item.get("time"), dict) else {}
    for key in ("updated", "created"):
        value = item.get(key)
        if value is not None:
            try:
                return int(value)
            except Exception:
                pass
        value = time_obj.get(key)
        if value is not None:
            try:
                return int(value)
            except Exception:
                pass
    return 0

def normalize(path):
    if not path:
        return ""
    return os.path.realpath(path)

before = parse(before_raw)
after = parse(after_raw)
started_at_ms = int(started_at_ms_raw or "0")
allow_existing_fallback = allow_existing_fallback_raw == "1"
before_ids = {item.get("id") for item in before if item.get("id")}
workdir = normalize(workdir)
project_dir = normalize(project_dir)

def in_scope(item):
    directory = normalize(item.get("directory", ""))
    return directory != "" and directory in {workdir, project_dir}

def choose(candidates):
    ranked = sorted(
        [item for item in candidates if item.get("id")],
        key=lambda item: timestamp(item),
        reverse=True,
    )
    if ranked:
        print(ranked[0]["id"])
        return True
    return False

new_sessions = [item for item in after if item.get("id") not in before_ids]
updated_sessions = [item for item in after if timestamp(item) > started_at_ms]

candidate_pools = [
    [item for item in new_sessions if in_scope(item)],
    [item for item in updated_sessions if in_scope(item)],
]

if allow_existing_fallback:
    candidate_pools.append([item for item in after if in_scope(item)])

for pool in candidate_pools:
    if choose(pool):
        break
PY
    return 0
  fi

  get_latest_session_id
}

get_transcripts_dir() {
  printf '%s\n' "${CLAUDE_CONFIG_DIR:-$HOME/.claude}/transcripts"
}

get_storage_session_diff_dir() {
  printf '%s\n' "$HOME/.local/share/opencode/storage/session_diff"
}

resolve_session_directory() {
  local session_id="$1"
  local output_file

  output_file=$(mktemp)
  if ! "$REAL_OPENCODE" export "$session_id" >"$output_file" 2>/dev/null; then
    rm -f "$output_file"
    return 1
  fi

  if [ ! -s "$output_file" ]; then
    rm -f "$output_file"
    return 1
  fi

  if command -v python3 >/dev/null 2>&1; then
    python3 - "$output_file" <<'PY'
import json
from pathlib import Path
import sys

raw = Path(sys.argv[1]).read_text()
start = raw.find('{')
if start == -1:
    raise SystemExit(1)

try:
    data = json.loads(raw[start:])
except Exception:
    raise SystemExit(1)

directory = ((data.get("info") or {}).get("directory") or "")
if directory:
    print(directory)
PY
    local status=$?
    rm -f "$output_file"
    return $status
  fi

  rm -f "$output_file"
  return 1
}

get_scoped_artifact_session_id_since() {
  local timestamp_file="$1"
  local workdir="$2"
  local project_dir="$3"

  if ! command -v python3 >/dev/null 2>&1; then
    return 1
  fi

  local candidates
  candidates=$(python3 - "$timestamp_file" "$HOME" "${CLAUDE_CONFIG_DIR:-$HOME/.claude}" <<'PY'
import os
import sys

timestamp_file, home_dir, claude_dir = sys.argv[1:4]

try:
    threshold = os.path.getmtime(timestamp_file)
except OSError:
    raise SystemExit(1)

sources = [
    (os.path.join(home_dir, '.local', 'share', 'opencode', 'storage', 'session_diff'), '.json'),
    (os.path.join(claude_dir, 'transcripts'), '.jsonl'),
]

latest = {}
for directory, suffix in sources:
    if not os.path.isdir(directory):
        continue
    for entry in os.scandir(directory):
        if not entry.is_file() or not entry.name.endswith(suffix):
            continue
        try:
            mtime = entry.stat().st_mtime
        except OSError:
            continue
        if mtime <= threshold:
            continue
        session_id = entry.name[:-len(suffix)]
        latest[session_id] = max(latest.get(session_id, -1), mtime)

for session_id, mtime in sorted(latest.items(), key=lambda item: item[1], reverse=True):
    print(session_id)
PY
  ) || return 1

  local session_id=""
  local session_dir=""
  local normalized_session_dir=""
  local normalized_workdir=""
  local normalized_project_dir=""
  normalized_workdir=$(python3 - "$workdir" <<'PY'
import os, sys
print(os.path.realpath(sys.argv[1]))
PY
)
  normalized_project_dir=$(python3 - "$project_dir" <<'PY'
import os, sys
print(os.path.realpath(sys.argv[1]))
PY
)

  while IFS= read -r session_id; do
    [ -n "$session_id" ] || continue
    session_dir=$(resolve_session_directory "$session_id" || true)
    [ -n "$session_dir" ] || continue
    normalized_session_dir=$(python3 - "$session_dir" <<'PY'
import os, sys
print(os.path.realpath(sys.argv[1]))
PY
)
    if [ "$normalized_session_dir" = "$normalized_workdir" ] || [ "$normalized_session_dir" = "$normalized_project_dir" ]; then
      printf '%s\n' "$session_id"
      return 0
    fi
  done <<EOF
$candidates
EOF

  return 1
}

get_latest_storage_session_id_since() {
  local timestamp_file="$1"
  local storage_dir
  storage_dir=$(get_storage_session_diff_dir)

  if [ ! -d "$storage_dir" ]; then
    return 1
  fi

  if command -v python3 >/dev/null 2>&1; then
    python3 - "$storage_dir" "$timestamp_file" <<'PY'
import os
import sys

storage_dir, timestamp_file = sys.argv[1:3]

try:
    threshold = os.path.getmtime(timestamp_file)
except OSError:
    raise SystemExit(1)

latest = None
latest_mtime = -1.0

for entry in os.scandir(storage_dir):
    if not entry.is_file() or not entry.name.endswith('.json'):
        continue
    try:
        mtime = entry.stat().st_mtime
    except OSError:
        continue
    if mtime <= threshold:
        continue
    if mtime > latest_mtime:
        latest_mtime = mtime
        latest = entry.name[:-5]

if latest:
    print(latest)
PY
    return 0
  fi

  return 1
}

get_latest_transcript_session_id_since() {
  local timestamp_file="$1"
  local transcripts_dir
  transcripts_dir=$(get_transcripts_dir)

  if [ ! -d "$transcripts_dir" ]; then
    return 1
  fi

  if command -v python3 >/dev/null 2>&1; then
    python3 - "$transcripts_dir" "$timestamp_file" <<'PY'
import os
import sys

transcripts_dir, timestamp_file = sys.argv[1:3]

try:
    threshold = os.path.getmtime(timestamp_file)
except OSError:
    raise SystemExit(1)

latest = None
latest_mtime = -1.0

for entry in os.scandir(transcripts_dir):
    if not entry.is_file() or not entry.name.endswith('.jsonl'):
        continue
    try:
        mtime = entry.stat().st_mtime
    except OSError:
        continue
    if mtime <= threshold:
        continue
    if mtime > latest_mtime:
        latest_mtime = mtime
        latest = entry.name[:-6]

if latest:
    print(latest)
PY
    return 0
  fi

  return 1
}

main_prompt_requests_ignore_memory() {
  if [ "${1:-}" != "run" ]; then
    return 1
  fi

  local joined
  joined=$(printf '%s\n' "$*" | tr '[:upper:]' '[:lower:]')
  printf '%s\n' "$joined" | grep -Eq "(ignore|don't use|do not use|without|skip)[[:space:]]+(the[[:space:]]+)?memory|memory[[:space:]]+((should|must)[[:space:]]+be[[:space:]]+)?ignored"
}

wait_for_scoped_session_id_since() {
  local before_json="$1"
  local started_at_ms="$2"
  local timestamp_file="$3"
  local wait_seconds="${4:-5}"
  local allow_existing_fallback="${5:-1}"
  local attempt=0
  local session_id=""

  while [ "$attempt" -lt "$wait_seconds" ]; do
    session_id=$(get_session_target_id "$before_json" "$started_at_ms" "$WORKING_DIR" "$PROJECT_SCOPE_DIR" "$allow_existing_fallback" || true)
    if [ -z "$session_id" ]; then
      session_id=$(get_scoped_artifact_session_id_since "$timestamp_file" "$WORKING_DIR" "$PROJECT_SCOPE_DIR" || true)
    fi
    if [ -n "$session_id" ]; then
      printf '%s\n' "$session_id"
      return 0
    fi
    sleep 1
    attempt=$((attempt + 1))
  done

  return 1
}

wait_for_session_target_id() {
  local before_json="$1"
  local started_at_ms="$2"
  local wait_seconds="${3:-5}"

  wait_for_scoped_session_id_since "$before_json" "$started_at_ms" "$TIMESTAMP_FILE" "$wait_seconds"
}

get_fork_cleanup_candidate_id() {
  local started_at_ms="$1"
  local parent_title="$2"
  local workdir="$3"
  local project_dir="$4"
  local db_path
  db_path=$(get_opencode_db_path)

  if [ -z "$started_at_ms" ] || [ -z "$parent_title" ] || [ ! -f "$db_path" ] || ! command -v python3 >/dev/null 2>&1; then
    return 1
  fi

  python3 - "$db_path" "$started_at_ms" "$parent_title" "$workdir" "$project_dir" <<'PY'
import os
import re
import sqlite3
import sys

db_path, started_at_ms_raw, parent_title, workdir, project_dir = sys.argv[1:6]
started_at_ms = int(started_at_ms_raw or "0")
scope = {os.path.realpath(path) for path in (workdir, project_dir) if path}
title_pattern = re.compile(rf"^{re.escape(parent_title)} \(fork #\d+\)$")

try:
    conn = sqlite3.connect(f"file:{db_path}?mode=ro", uri=True)
    rows = conn.execute(
        "SELECT id, title, directory, time_created FROM session WHERE time_created >= ? ORDER BY time_created DESC",
        (started_at_ms,),
    ).fetchall()
except Exception:
    raise SystemExit(1)
finally:
    try:
        conn.close()
    except Exception:
        pass

matches = []
for session_id, title, directory, time_created in rows:
    if not session_id or not title or not directory or not time_created:
        continue
    if os.path.realpath(directory) not in scope:
        continue
    if not title_pattern.match(title):
        continue
    matches.append(session_id)

if len(matches) == 1:
    print(matches[0])
PY
}

wait_for_fork_cleanup_candidate_id() {
  local started_at_ms="$1"
  local parent_title="$2"
  local wait_seconds="${3:-5}"
  local attempt=0
  local session_id=""

  while [ "$attempt" -lt "$wait_seconds" ]; do
    session_id=$(get_fork_cleanup_candidate_id "$started_at_ms" "$parent_title" "$WORKING_DIR" "$PROJECT_SCOPE_DIR" || true)
    if [ -n "$session_id" ]; then
      printf '%s\n' "$session_id"
      return 0
    fi
    sleep 1
    attempt=$((attempt + 1))
  done

  return 1
}

file_mtime_secs() {
  local file="$1"
  if [ ! -f "$file" ]; then
    echo 0
    return 0
  fi

  if stat -c %Y "$file" >/dev/null 2>&1; then
    stat -c %Y "$file"
    return 0
  fi

  stat -f %m "$file"
}

# Claude-style lock/mtime semantics:
# - lock file CONTENT (PID) = current holder
# - lock file MTIME = last successful consolidation timestamp
read_last_consolidated_at_secs() {
  file_mtime_secs "$CONSOLIDATION_LOCK_FILE"
}

set_file_mtime_secs() {
  local file="$1"
  local secs="$2"

  if command -v python3 >/dev/null 2>&1; then
    python3 - "$file" "$secs" <<'PY'
import os
import sys

path = sys.argv[1]
secs = int(sys.argv[2])
os.utime(path, (secs, secs))
PY
    return 0
  fi

  # Best effort fallback; may not be portable across all environments.
  touch -d "@$secs" "$file" >/dev/null 2>&1 || true
}

acquire_simple_lock() {
  local lock_file="$1"
  local lock_name="$2"

  if [ -f "$lock_file" ]; then
    local lock_pid
    lock_pid=$(cat "$lock_file" 2>/dev/null || true)
    if [ -n "$lock_pid" ] && kill -0 "$lock_pid" 2>/dev/null; then
      log "Another $lock_name is already running (PID $lock_pid), skipping"
      return 1
    fi
    rm -f "$lock_file"
  fi

  echo $$ > "$lock_file"
  return 0
}

release_simple_lock() {
  local lock_file="$1"
  rm -f "$lock_file"
}

count_sessions_touched_since_ms() {
  local since_ms="$1"
  local exclude_session_id="$2"

  if ! command -v jq >/dev/null 2>&1; then
    echo ""
    return 1
  fi

  local session_json
  session_json=$(get_session_list_json "$AUTODREAM_SCAN_LIMIT") || {
    echo ""
    return 1
  }

  echo "$session_json" | jq -r --argjson since "$since_ms" --arg exclude "$exclude_session_id" '
    [ .[]
      | select((.id // "") != $exclude)
      | select(((.time.updated // .time.created // 0) | tonumber) > $since)
    ] | length
  '
}

CONSOLIDATION_PRIOR_MTIME=0

try_acquire_consolidation_lock() {
  local path="$CONSOLIDATION_LOCK_FILE"
  local now mtime holder age

  # Returns prior mtime via CONSOLIDATION_PRIOR_MTIME so callers can rollback
  # on failure (preserving last successful consolidation time semantics).

  now=$(date +%s)
  mtime=0
  holder=""

  if [ -f "$path" ]; then
    mtime=$(file_mtime_secs "$path")
    holder=$(cat "$path" 2>/dev/null || true)
    age=$((now - mtime))

    if [ "$age" -lt "$AUTODREAM_STALE_LOCK_SECS" ] && [ -n "$holder" ] && kill -0 "$holder" 2>/dev/null; then
      log "Auto-dream lock held by live PID $holder (${age}s old), skipping"
      return 1
    fi
  fi

  mkdir -p "$(dirname "$path")"
  echo $$ > "$path"

  local verify
  verify=$(cat "$path" 2>/dev/null || true)
  if [ "$verify" != "$$" ]; then
    return 1
  fi

  CONSOLIDATION_PRIOR_MTIME="$mtime"
  return 0
}

rollback_consolidation_lock() {
  local prior_mtime="$1"
  local path="$CONSOLIDATION_LOCK_FILE"

  if [ "$prior_mtime" -eq 0 ]; then
    rm -f "$path"
    return 0
  fi

  : > "$path"
  set_file_mtime_secs "$path" "$prior_mtime"
}

cleanup_forked_sessions() {
  local started_at_ms="$1"
  local parent_title="$2"

  if [ -z "$started_at_ms" ] || [ -z "$parent_title" ]; then
    return 0
  fi

  if ! command -v python3 >/dev/null 2>&1; then
    return 0
  fi

  if ! python3 - <<'PY' >/dev/null 2>&1
pass
PY
  then
    return 0
  fi

  local fork_id
  fork_id=$(wait_for_fork_cleanup_candidate_id "$started_at_ms" "$parent_title" "$SESSION_WAIT_SECONDS" || true)

  [ -n "$fork_id" ] || return 0

  if "$REAL_OPENCODE" session delete "$fork_id" >/dev/null 2>&1; then
    log "Cleaned up forked session $fork_id"
  fi
}

session_has_conversation() {
  local session_id="$1"
  local transcript_file
  transcript_file="$(get_transcripts_dir)/${session_id}.jsonl"

  if [ -f "$transcript_file" ]; then
    local line_count
    line_count=$(wc -l < "$transcript_file")
    # Empty sessions have at most 1 line (the initial user entry with no content).
    # Real sessions have 3+ lines (user + tool_use + tool_result at minimum).
    [ "$line_count" -gt 1 ]
    return $?
  fi

  # Transcript not found — assume content exists to avoid skipping a valid session.
  return 0
}

transcript_fingerprint() {
  local transcript_file="$1"
  local stat_output

  if [ ! -f "$transcript_file" ]; then
    return 1
  fi

  if command -v python3 >/dev/null 2>&1; then
    python3 - "$transcript_file" <<'PY'
import os
import sys

path = sys.argv[1]

try:
    file_stat = os.stat(path)
except OSError:
    raise SystemExit(1)

mtime = getattr(file_stat, "st_mtime_ns", int(file_stat.st_mtime * 1_000_000_000))
print(f"{file_stat.st_size}\t{mtime}")
PY
    return $?
  fi

  if stat_output=$(stat -f '%z	%m' "$transcript_file" 2>/dev/null); then
    printf '%s\n' "$stat_output"
    return 0
  fi

  if stat_output=$(stat -c '%s	%Y' "$transcript_file" 2>/dev/null); then
    printf '%s\n' "$stat_output"
    return 0
  fi

  return 1
}

write_transcript_checkpoint() {
  local output_file="$1"
  local transcripts_dir
  transcripts_dir="$(get_transcripts_dir)"

  : > "$output_file"
  [ -d "$transcripts_dir" ] || return 0

  if command -v python3 >/dev/null 2>&1; then
    python3 - "$transcripts_dir" > "$output_file" <<'PY'
import os
import stat
import sys

transcripts_dir = sys.argv[1]

try:
    filenames = os.listdir(transcripts_dir)
except OSError:
    raise SystemExit(0)

for filename in filenames:
    if not filename.endswith(".jsonl"):
        continue
    path = os.path.join(transcripts_dir, filename)
    try:
        file_stat = os.stat(path)
    except OSError:
        continue
    if not stat.S_ISREG(file_stat.st_mode):
        continue
    session_id = filename[:-6]
    if not session_id:
        continue
    mtime = getattr(file_stat, "st_mtime_ns", int(file_stat.st_mtime * 1_000_000_000))
    print(f"{session_id}\t{file_stat.st_size}\t{mtime}")
PY
    return 0
  fi

  find "$transcripts_dir" -maxdepth 1 -type f -name '*.jsonl' -print 2>/dev/null | while IFS= read -r transcript_file; do
    local filename session_id fingerprint
    filename="$(basename "$transcript_file")"
    session_id="${filename%.jsonl}"
    fingerprint="$(transcript_fingerprint "$transcript_file" || true)"
    [ -n "$session_id" ] && [ -n "$fingerprint" ] || continue
    printf '%s\t%s\n' "$session_id" "$fingerprint"
  done > "$output_file"
}

read_transcript_checkpoint() {
  local session_id="$1"

  [ -f "$TRANSCRIPT_CHECKPOINT_FILE" ] || return 1
  awk -F '\t' -v id="$session_id" '$1 == id { print $2 "\t" $3; found=1; exit } END { exit found ? 0 : 1 }' "$TRANSCRIPT_CHECKPOINT_FILE"
}

session_has_incremental_activity() {
  local session_id="$1"
  local transcript_file previous current
  transcript_file="$(get_transcripts_dir)/${session_id}.jsonl"

  if [ -f "$transcript_file" ]; then
    current="$(transcript_fingerprint "$transcript_file" || true)"
    previous="$(read_transcript_checkpoint "$session_id" || true)"
    if [ -z "$previous" ]; then
      return 0
    fi
    [ "$current" != "$previous" ]
    return $?
  fi

  # If no transcript is available, keep the existing conservative behavior:
  # session_diff/session-list discovery may still have found a valid new turn.
  return 0
}

run_extraction_if_needed() {
  local session_id="$1"
  local memory_written_during_session="$2"

  if [ "$EXTRACT_ENABLED" = "0" ]; then
    return 0
  fi

  if [ "$memory_written_during_session" = "1" ]; then
    log "Main agent already wrote memories during session, skipping extraction"
    return 0
  fi

  if ! acquire_simple_lock "$EXTRACT_LOCK_FILE" "memory extraction"; then
    return 0
  fi

  log "Extracting memories from session $session_id..."
  log "Extraction log: $EXTRACT_LOG_FILE"

  local parent_session_title
  parent_session_title=$(get_session_title_from_db "$session_id" || true)

  local cmd=("$REAL_OPENCODE" run -s "$session_id" --fork --dir "$WORKING_DIR")
  if [ -n "$EXTRACT_MODEL" ]; then
    cmd+=(-m "$EXTRACT_MODEL")
  fi
  if [ -n "$EXTRACT_AGENT" ]; then
    cmd+=(--agent "$EXTRACT_AGENT")
  fi
  cmd+=("$EXTRACT_PROMPT")

  local fork_started_at_ms
  fork_started_at_ms=$(( $(date +%s) * 1000 ))

  if "${cmd[@]}" >> "$EXTRACT_LOG_FILE" 2>&1; then
    log "Memory extraction completed successfully"
  else
    local code=$?
    log "Memory extraction failed (exit code $code). Check $EXTRACT_LOG_FILE for details"
  fi

  cleanup_forked_sessions "$fork_started_at_ms" "$parent_session_title"
  release_simple_lock "$EXTRACT_LOCK_FILE"
}

run_autodream_if_needed() {
  local session_id="$1"

  if [ "$AUTODREAM_ENABLED" = "0" ]; then
    return 0
  fi

  if ! command -v jq >/dev/null 2>&1; then
    log "jq not found, skipping auto-dream (requires JSON session parsing)"
    return 0
  fi

  local last_at now hours_since since_ms touched_count
  last_at=$(read_last_consolidated_at_secs)
  now=$(date +%s)

  hours_since=$(((now - last_at) / 3600))
  if [ "$hours_since" -lt "$AUTODREAM_MIN_HOURS" ]; then
    return 0
  fi

  since_ms=$((last_at * 1000))
  touched_count=$(count_sessions_touched_since_ms "$since_ms" "$session_id" || true)
  if [ -z "$touched_count" ]; then
    log "Unable to inspect touched sessions, skipping auto-dream"
    return 0
  fi

  if [ "$touched_count" -lt "$AUTODREAM_MIN_SESSIONS" ]; then
    return 0
  fi

  if ! try_acquire_consolidation_lock; then
    return 0
  fi

  log "Auto-dream firing (${hours_since}h since last consolidation, ${touched_count} sessions touched)"
  log "Auto-dream log: $AUTODREAM_LOG_FILE"

  local parent_session_title
  parent_session_title=$(get_session_title_from_db "$session_id" || true)

  local cmd=("$REAL_OPENCODE" run -s "$session_id" --fork --dir "$WORKING_DIR")
  if [ -n "$AUTODREAM_MODEL" ]; then
    cmd+=(-m "$AUTODREAM_MODEL")
  fi
  if [ -n "$AUTODREAM_AGENT" ]; then
    cmd+=(--agent "$AUTODREAM_AGENT")
  fi
  cmd+=("$AUTODREAM_PROMPT")

  local fork_started_at_ms
  fork_started_at_ms=$(( $(date +%s) * 1000 ))

  if "${cmd[@]}" >> "$AUTODREAM_LOG_FILE" 2>&1; then
    log "Auto-dream consolidation completed successfully"
    # Keep lock mtime at "now" to represent last consolidated timestamp.
  else
    local code=$?
    log "Auto-dream consolidation failed (exit code $code). Rolling back gate timestamp"
    rollback_consolidation_lock "$CONSOLIDATION_PRIOR_MTIME"
  fi

  cleanup_forked_sessions "$fork_started_at_ms" "$parent_session_title"
}

run_post_session_tasks() {
  local session_id="$1"
  local memory_written_during_session="$2"

  run_extraction_if_needed "$session_id" "$memory_written_during_session"
  run_autodream_if_needed "$session_id"
}

run_post_session_for_invocation() {
  local session_id
  local memory_written_during_session

  # Capture the session ID for this invocation. In background mode this wait
  # must not delay the visible exit of the wrapped opencode process.
  session_id=$(wait_for_session_target_id "$PRE_SESSION_JSON" "$SESSION_CAPTURE_STARTED_AT_MS" "$SESSION_WAIT_SECONDS" || true)
  if [ -z "$session_id" ]; then
    log "No session found, skipping post-session memory maintenance"
    cleanup_timestamp
    return 0
  fi

  # Skip if session had no real conversation (e.g. user opened TUI and exited).
  if ! session_has_conversation "$session_id"; then
    log "Session $session_id has no conversation, skipping post-session memory maintenance"
    cleanup_timestamp
    return 0
  fi

  if ! session_has_incremental_activity "$session_id"; then
    log "Session $session_id has no new transcript activity, skipping post-session memory maintenance"
    cleanup_timestamp
    return 0
  fi

  memory_written_during_session=0
  if has_new_memories; then
    memory_written_during_session=1
  fi

  # Timestamp file is no longer needed after the check above.
  cleanup_timestamp

  run_post_session_tasks "$session_id" "$memory_written_during_session"
}

# ============================================================================
# Main
# ============================================================================

# Step 0: Create timestamp marker before running opencode
TIMESTAMP_FILE=$(mktemp)
TRANSCRIPT_CHECKPOINT_FILE=$(mktemp)
write_transcript_checkpoint "$TRANSCRIPT_CHECKPOINT_FILE"
SESSION_CAPTURE_STARTED_AT_MS=$(( $(date +%s) * 1000 ))
PRE_SESSION_JSON=$(get_session_list_json "$AUTODREAM_SCAN_LIMIT" 2>/dev/null || true)

# Step 1: Run the real opencode with all original arguments, capture exit code
opencode_exit=0
if main_prompt_requests_ignore_memory "$@"; then
  OPENCODE_MEMORY_IGNORE=1 "$REAL_OPENCODE" "$@" || opencode_exit=$?
else
  "$REAL_OPENCODE" "$@" || opencode_exit=$?
fi

# Step 2: If no maintenance task is enabled, exit early
if [ "$EXTRACT_ENABLED" = "0" ] && [ "$AUTODREAM_ENABLED" = "0" ]; then
  cleanup_timestamp
  exit $opencode_exit
fi

# Step 3: Run post-session maintenance (foreground for debug, background by default).
if [ "$FOREGROUND" = "1" ]; then
  run_post_session_for_invocation
else
  run_post_session_for_invocation &
  disown
  log "Post-session memory maintenance started in background (PID $!)"
fi

exit $opencode_exit