opencode-claude-memory 1.7.7 → 2.0.0

package/bin/opencode-memory

@@ -1,1436 +0,0 @@
-#!/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