luciazero 2.4.2 → 2.5.0

package/uninstall-codex.sh

@@ -11,6 +11,9 @@ SRC="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 AGENTS_MD="${CODEX_DIR}/AGENTS.md"
 START='<!-- luciazero:start -->'
 END='<!-- luciazero:end -->'
+# written inside the block, under the start marker, when the install had to add
+# a final newline to the user's content to make room for that marker
+ADDED_NL_MARK='<!-- luciazero:added-final-newline -->'
 MANAGED_DIR="${CODEX_DIR}/.luciazero-managed"
 
 catalog() { sed '/^[[:space:]]*#/d; /^[[:space:]]*$/d' "$1"; }
@@ -19,11 +22,18 @@ skill_inventory() {
   catalog "${SRC}/skills/aliases.txt"
 }
 
-# collision-proof backup path for $1 (two runs in the same second must not overwrite)
+# A free backup name for $1. Two runs in the same second must not overwrite
+# each other, and a name a symlink already holds is taken too: `-e` follows
+# the name and answers false for a symlink whose target is missing, which
+# would send the `cp` below straight through that symlink and out of the
+# config directory. This is a check, not a reservation -- the name is still
+# free to be taken between the test and the `cp` (roadmap R24). The
+# uninstaller's settings backup reserves its name with `O_CREAT | O_EXCL`
+# instead, which the shell has no portable equivalent for.
 bakpath() {
   B="$1.bak.$(date +%Y%m%d%H%M%S)"
   N=1
-  while [ -e "${B}" ]; do B="$1.bak.$(date +%Y%m%d%H%M%S).${N}"; N=$((N+1)); done
+  while [ -e "${B}" ] || [ -L "${B}" ]; do B="$1.bak.$(date +%Y%m%d%H%M%S).${N}"; N=$((N+1)); done
   printf '%s' "${B}"
 }
 
@@ -32,16 +42,91 @@ same_tree() {
     && diff -qr "$1" "$2" >/dev/null 2>&1
 }
 
-tree_parents_safe() {
-  [ ! -L "$(dirname "$1")" ] && [ ! -L "$(dirname "$2")" ]
+# A symlink anywhere between the config dir and a path we are about to delete
+# can redirect that delete outside the config dir, so every directory on the
+# way down has to be a real one. The config dir itself may be a symlink: where
+# it lives is the user's own choice.
+parents_safe() {
+  PS_ROOT="${CODEX_DIR%/}"
+  PS_DIR="$(dirname "$1")"
+  while [ "${PS_DIR}" != "${PS_ROOT}" ] && [ "${PS_DIR}" != "/" ] && [ "${PS_DIR}" != "." ]; do
+    [ ! -L "${PS_DIR}" ] || return 1
+    PS_NEXT="$(dirname "${PS_DIR}")"
+    [ "${PS_NEXT}" != "${PS_DIR}" ] || break
+    PS_DIR="${PS_NEXT}"
+  done
+  return 0
+}
+
+# Does $1 end in a newline? A last line without one is content like any other,
+# and `awk` cannot pass it through: print terminates every record it writes, so
+# a rewrite that goes through awk hands such a file back one byte longer.
+ends_with_newline() {
+  [ -s "$1" ] && [ -z "$(tail -c 1 "$1")" ]
+}
+
+# Write $1 with its marker block removed and every other byte kept, including a
+# last line that carries no newline.
+#
+# The newline directly above the start marker is removed with the block when
+# the block says the installer put it there. The install has to: a start marker
+# only counts on a line of its own, so a file whose last line was unterminated
+# needs one before the block can be appended. That newline is the installer's,
+# not the user's, and nothing in the finished file distinguishes it from a
+# newline the user typed -- so the installer records it, on the line under the
+# start marker, where the markers are its provenance exactly as they are the
+# blank line's. The record is honoured only while the block is still the last
+# thing in the file, which is where the install put it; a user who has moved
+# the block since has moved that newline into the middle of their own text,
+# where it is no longer provably ours and stays.
+strip_marker_block() {
+  if ends_with_newline "$1"; then SMB_SRC_NL=1; else SMB_SRC_NL=0; fi
+  awk -v s="${START}" -v e="${END}" -v mark="${ADDED_NL_MARK}" -v srcnl="${SMB_SRC_NL}" '
+    $0==s {inblock=1; head=1; blockend=NR; next}
+    $0==e {inblock=0; blockend=NR; next}
+    inblock {if (head && $0==mark) added=1; head=0; blockend=NR; next}
+    {n++; keep[n]=$0; lastkept=NR}
+    END {
+      chop = (added && n > 0 && blockend == NR)
+      for (i = 1; i <= n; i++) {
+        printf "%s", keep[i]
+        if (i < n) printf "\n"
+      }
+      if (n > 0 && !chop && !(lastkept == NR && srcnl == 0)) printf "\n"
+    }
+  ' "$1"
+}
+
+# Exactly one well-formed marker pair, or none at all. Anything else — a start
+# with no end, a second pair, a pair nested inside another — has no defined
+# meaning, and the awk rewrites below would answer it by dropping whatever
+# follows the opening marker. AGENTS.md is the user's file; an ambiguous one is
+# left exactly as it is, down to the byte, rather than repaired by guesswork.
+# Markers count only on a line of their own, which is what the rewrites match.
+marker_block_ok() {
+  MB_FILE="$1"
+  [ -f "${MB_FILE}" ] || return 0
+  MB_S="$(grep -cxF "${START}" "${MB_FILE}" || true)"
+  MB_E="$(grep -cxF "${END}" "${MB_FILE}" || true)"
+  [ "${MB_S}" = 0 ] && [ "${MB_E}" = 0 ] && return 0
+  if [ "${MB_S}" = 1 ] && [ "${MB_E}" = 1 ]; then
+    MB_SL="$(grep -nxF "${START}" "${MB_FILE}" | cut -d: -f1)"
+    MB_EL="$(grep -nxF "${END}" "${MB_FILE}" | cut -d: -f1)"
+    [ "${MB_SL}" -lt "${MB_EL}" ] && return 0
+  fi
+  return 1
 }
 
 remove_managed_tree() {
   RT_DST="$1"; RT_SNAPSHOT="$2"; RT_SHIPPED="$3"; RT_LABEL="$4"; RT_ALLOW_SHIPPED="${5:-1}"
+  # ancestry first, and return: refusing further down would still leave the
+  # snapshot cleanup below to delete whatever the symlink points at
+  if ! parents_safe "${RT_DST}" || ! parents_safe "${RT_SNAPSHOT}"; then
+    echo "  !!  ${RT_LABEL} has a symlinked parent; left untouched" >&2
+    return 0
+  fi
   if [ ! -e "${RT_DST}" ] && [ ! -L "${RT_DST}" ]; then
     echo "  ok  ${RT_LABEL} (already absent)"
-  elif ! tree_parents_safe "${RT_DST}" "${RT_SNAPSHOT}"; then
-    echo "  !!  ${RT_LABEL} has a symlinked parent; left untouched" >&2
   elif same_tree "${RT_DST}" "${RT_SNAPSHOT}" \
     || { [ "${RT_ALLOW_SHIPPED}" = 1 ] && [ ! -e "${RT_SNAPSHOT}" ] && same_tree "${RT_DST}" "${RT_SHIPPED}"; }; then
     rm -rf "${RT_DST}"
@@ -67,7 +152,8 @@ remove_managed_tree "${CODEX_DIR}/skills/luciazero-bootstrap" \
   "skills/luciazero-bootstrap (retired alias)" 0
 
 AGENT_STAGE_ROOT="$(mktemp -d)"
-trap 'rm -rf "${AGENT_STAGE_ROOT}"' EXIT
+AGENTS_TMP=""
+trap 'rm -rf "${AGENT_STAGE_ROOT}"; [ -z "${AGENTS_TMP}" ] || rm -f "${AGENTS_TMP}"' EXIT
 while IFS= read -r AGENT_NAME; do
   AGENT_SOURCE="${AGENT_STAGE_ROOT}/${AGENT_NAME}"
   mkdir -p "${AGENT_SOURCE}"
@@ -89,15 +175,43 @@ if [ -f "${LEGACY_HANDOFF}/SKILL.md" ]; then
   fi
 fi
 
-if [ -f "${AGENTS_MD}" ] && grep -qF "${START}" "${AGENTS_MD}"; then
+if [ -f "${AGENTS_MD}" ] && grep -qxF "${START}" "${AGENTS_MD}" && ! marker_block_ok "${AGENTS_MD}"; then
+  # the skills are gone by now, which is safe on its own; the file is not ours
+  # to interpret, so it keeps every byte it has, backup included
+  echo "  !!  AGENTS.md carries ambiguous Luciazero markers; left untouched" >&2
+  echo "      expected exactly one '${START}' ... '${END}' pair, on their own lines" >&2
+elif [ -f "${AGENTS_MD}" ] && grep -qxF "${START}" "${AGENTS_MD}"; then
   BACKUP="$(bakpath "${AGENTS_MD}")"
-  cp "${AGENTS_MD}" "${BACKUP}"
-  awk -v s="${START}" -v e="${END}" '
-    $0==s {inblock=1; next}
-    $0==e {inblock=0; next}
-    !inblock {print}
-  ' "${AGENTS_MD}" > "${AGENTS_MD}.tmp"
-  mv "${AGENTS_MD}.tmp" "${AGENTS_MD}"
+  cp -p "${AGENTS_MD}" "${BACKUP}"
+  # The block goes and nothing else does, which is now the whole round trip
+  # rather than a compromise. `install-codex.sh` used to write a blank
+  # separator above the start marker, and removing only the block left it
+  # behind, so a file the user wrote grew one blank line per cycle. Removing
+  # it from here would have meant guessing whose that blank was -- the Claude
+  # side may drop its separator only because `install.sh` records that it
+  # added it and hashes the file it left, and there is no such record on this
+  # side. The install answered it instead: it appends its block without a
+  # separator and keeps the blank that spaces the doctrine inside the markers,
+  # where deleting the block deletes exactly what the install added. A block
+  # the user has since moved carries that blank with it, so a rearranged file
+  # comes back byte for byte too. The one byte the install cannot leave alone
+  # is a final newline on content that had none, because the start marker needs
+  # a line of its own; it records that newline inside the block, and
+  # `strip_marker_block` takes it away with the rest.
+  # `${AGENTS_MD}.tmp` is a name anyone with write access to the config dir can
+  # pre-create as a symlink, and both the rewrite and the rename would then
+  # follow it: the awk output lands wherever it points, and the symlink itself
+  # is published as AGENTS.md. mktemp picks a name nobody can predict and
+  # creates it exclusively; keeping it in the same directory keeps the rename
+  # on one filesystem, the way the Claude side already does it.
+  AGENTS_TMP="$(mktemp "${CODEX_DIR}/.luciazero-agents-md.XXXXXX")"
+  # mktemp makes its file 0600 and the rename publishes that file: copying the
+  # backup, which kept the original's mode, carries the mode onto it. The
+  # redirection below replaces the content and leaves the mode alone.
+  cp -p "${BACKUP}" "${AGENTS_TMP}"
+  strip_marker_block "${AGENTS_MD}" > "${AGENTS_TMP}"
+  mv "${AGENTS_TMP}" "${AGENTS_MD}"
+  AGENTS_TMP=""
   [ -s "${AGENTS_MD}" ] || rm -f "${AGENTS_MD}"
   echo "  ok  removed doctrine block (backup: $(basename "${BACKUP}"))"
 else

package/uninstall.sh

@@ -11,6 +11,27 @@ SRC="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 DOCTRINE="luciazero.md"
 IMPORT_LINE="@${DOCTRINE}"
 GLOBAL_MD="${CLAUDE_DIR}/CLAUDE.md"
+IMPORT_PROVENANCE="${CLAUDE_DIR}/.luciazero-import"
+
+sha_of() {
+  if command -v shasum >/dev/null 2>&1; then shasum -a 256 < "$1" | cut -d' ' -f1
+  elif command -v sha256sum >/dev/null 2>&1; then sha256sum < "$1" | cut -d' ' -f1
+  else echo ""; fi
+}
+
+# Read only a plain file of our own, proved by the marker install.sh writes as
+# its first line. Following a symlink, or trusting any regular file that
+# happens to sit at this path, would let somebody else's content decide
+# whether a blank line in the user's CLAUDE.md gets deleted.
+IMPORT_MARKER="luciazero-managed: import-provenance"
+provenance_is_ours() {
+  [ -f "${IMPORT_PROVENANCE}" ] && [ ! -L "${IMPORT_PROVENANCE}" ] \
+    && [ "$(head -n 1 "${IMPORT_PROVENANCE}" 2>/dev/null)" = "${IMPORT_MARKER}" ]
+}
+read_provenance() {
+  provenance_is_ours || return 0
+  sed -n '2p' "${IMPORT_PROVENANCE}" 2>/dev/null || true
+}
 MANAGED_DIR="${CLAUDE_DIR}/.luciazero-managed"
 
 catalog() { sed '/^[[:space:]]*#/d; /^[[:space:]]*$/d' "$1"; }
@@ -19,11 +40,18 @@ skill_inventory() {
   catalog "${SRC}/skills/aliases.txt"
 }
 
-# collision-proof backup path for $1 (two runs in the same second must not overwrite)
+# A free backup name for $1. Two runs in the same second must not overwrite
+# each other, and a name a symlink already holds is taken too: `-e` follows
+# the name and answers false for a symlink whose target is missing, which
+# would send the `cp` below straight through that symlink and out of the
+# config directory. This is a check, not a reservation -- the name is still
+# free to be taken between the test and the `cp` (roadmap R24). The
+# uninstaller's settings backup reserves its name with `O_CREAT | O_EXCL`
+# instead, which the shell has no portable equivalent for.
 bakpath() {
   B="$1.bak.$(date +%Y%m%d%H%M%S)"
   N=1
-  while [ -e "${B}" ]; do B="$1.bak.$(date +%Y%m%d%H%M%S).${N}"; N=$((N+1)); done
+  while [ -e "${B}" ] || [ -L "${B}" ]; do B="$1.bak.$(date +%Y%m%d%H%M%S).${N}"; N=$((N+1)); done
   printf '%s' "${B}"
 }
 
@@ -32,16 +60,32 @@ same_tree() {
     && diff -qr "$1" "$2" >/dev/null 2>&1
 }
 
-tree_parents_safe() {
-  [ ! -L "$(dirname "$1")" ] && [ ! -L "$(dirname "$2")" ]
+# A symlink anywhere between the config dir and a path we are about to delete
+# can redirect that delete outside the config dir, so every directory on the
+# way down has to be a real one. The config dir itself may be a symlink: where
+# it lives is the user's own choice.
+parents_safe() {
+  PS_ROOT="${CLAUDE_DIR%/}"
+  PS_DIR="$(dirname "$1")"
+  while [ "${PS_DIR}" != "${PS_ROOT}" ] && [ "${PS_DIR}" != "/" ] && [ "${PS_DIR}" != "." ]; do
+    [ ! -L "${PS_DIR}" ] || return 1
+    PS_NEXT="$(dirname "${PS_DIR}")"
+    [ "${PS_NEXT}" != "${PS_DIR}" ] || break
+    PS_DIR="${PS_NEXT}"
+  done
+  return 0
 }
 
 remove_managed_tree() {
   RT_DST="$1"; RT_SNAPSHOT="$2"; RT_SHIPPED="$3"; RT_LABEL="$4"; RT_ALLOW_SHIPPED="${5:-1}"
+  # ancestry first, and return: refusing further down would still leave the
+  # snapshot cleanup below to delete whatever the symlink points at
+  if ! parents_safe "${RT_DST}" || ! parents_safe "${RT_SNAPSHOT}"; then
+    echo "  !!  ${RT_LABEL} has a symlinked parent; left untouched" >&2
+    return 0
+  fi
   if [ ! -e "${RT_DST}" ] && [ ! -L "${RT_DST}" ]; then
     echo "  ok  ${RT_LABEL} (already absent)"
-  elif ! tree_parents_safe "${RT_DST}" "${RT_SNAPSHOT}"; then
-    echo "  !!  ${RT_LABEL} has a symlinked parent; left untouched" >&2
   elif same_tree "${RT_DST}" "${RT_SNAPSHOT}" \
     || { [ "${RT_ALLOW_SHIPPED}" = 1 ] && [ ! -e "${RT_SNAPSHOT}" ] && same_tree "${RT_DST}" "${RT_SHIPPED}"; }; then
     rm -rf "${RT_DST}"
@@ -54,6 +98,10 @@ remove_managed_tree() {
 
 remove_managed_file() {
   RF_DST="$1"; RF_SNAPSHOT="$2"; RF_SHIPPED="$3"; RF_LABEL="$4"
+  if ! parents_safe "${RF_DST}" || ! parents_safe "${RF_SNAPSHOT}"; then
+    echo "  !!  ${RF_LABEL} has a symlinked parent; left untouched" >&2
+    return 0
+  fi
   if [ ! -e "${RF_DST}" ] && [ ! -L "${RF_DST}" ]; then
     echo "  ok  ${RF_LABEL} (already absent)"
   elif [ -f "${RF_DST}" ] && [ ! -L "${RF_DST}" ] \
@@ -92,6 +140,66 @@ done < <(catalog "${SRC}/claude/agents/catalog.txt")
 
 rmdir "${MANAGED_DIR}/skills" "${MANAGED_DIR}/agents" "${MANAGED_DIR}" 2>/dev/null || true
 
+# Agent Bus launcher. Only a regular file carrying the ownership marker is
+# ours to delete: a symlink is something the user made, and anything without
+# the marker is another program that happens to share the name.
+AGENTD_MARKER="luciazero-managed: agentd-launcher"
+AGENTD_SERVICE_MARKER="luciazero-managed: agentd-service"
+AGENTD_BIN_DIR="${LUCIAZERO_BIN_DIR:-${CLAUDE_DIR}/bin}"
+AGENTD_LAUNCHER="${AGENTD_BIN_DIR}/luciazero-agentd"
+# Both names install.sh writes. The long one is kept in its own variable
+# because the service is stopped through it before either is removed.
+AGENTD_NAMES="luciazero-agentd lucia"
+
+# The background service outlives this script unless it is stopped first.
+# Removing the launcher while a LaunchAgent or a systemd unit still points at
+# it leaves either a daemon serving after an uninstall or a service manager
+# restarting a file that is gone, so the service is dealt with first and the
+# launcher stays put if it could not be.
+AGENTD_KEEP=0
+AGENTD_SERVICE_ROOT="${LUCIAZERO_SERVICE_ROOT:-$HOME}"
+for AGENTD_SVC in "${AGENTD_SERVICE_ROOT}/Library/LaunchAgents/com.luciazero.agentd.plist" \
+  "${AGENTD_SERVICE_ROOT}/.config/systemd/user/luciazero-agentd.service"; do
+  [ -f "${AGENTD_SVC}" ] || continue
+  grep -qF "${AGENTD_SERVICE_MARKER}" "${AGENTD_SVC}" 2>/dev/null || continue
+  AGENTD_RUN=""
+  if [ -f "${AGENTD_LAUNCHER}" ] && grep -qF "${AGENTD_MARKER}" "${AGENTD_LAUNCHER}" 2>/dev/null; then
+    AGENTD_RUN="${AGENTD_LAUNCHER}"
+  fi
+  if [ -n "${AGENTD_RUN}" ] && "${AGENTD_RUN}" service uninstall >/dev/null 2>&1; then
+    echo "  ok  agent bus service stopped and removed"
+  elif [ -d "${SRC}/agentd/luciazero_agentd" ] && command -v python3 >/dev/null 2>&1 \
+    && PYTHONPATH="${SRC}/agentd" python3 -m luciazero_agentd service uninstall >/dev/null 2>&1; then
+    echo "  ok  agent bus service stopped and removed"
+  else
+    echo "  !!  the Agent Bus service is still installed (${AGENTD_SVC})" >&2
+    echo "      stop it first:  luciazero-agentd service uninstall" >&2
+    echo "      the launcher is left in place so the service does not restart a missing file" >&2
+    AGENTD_KEEP=1
+  fi
+done
+
+if [ "${AGENTD_KEEP}" = 0 ]; then
+  for AGENTD_NAME in ${AGENTD_NAMES}; do
+    AGENTD_TARGET="${AGENTD_BIN_DIR}/${AGENTD_NAME}"
+    if [ -L "${AGENTD_TARGET}" ]; then
+      echo "  !!  ${AGENTD_TARGET} is a symlink you made; left untouched" >&2
+    elif [ -f "${AGENTD_TARGET}" ]; then
+      if grep -qF "${AGENTD_MARKER}" "${AGENTD_TARGET}" 2>/dev/null; then
+        rm -f "${AGENTD_TARGET}"
+        echo "  ok  bin/${AGENTD_NAME}"
+      else
+        echo "  !!  ${AGENTD_TARGET} is not the Luciazero launcher; left untouched" >&2
+      fi
+    elif [ -e "${AGENTD_TARGET}" ]; then
+      echo "  !!  ${AGENTD_TARGET} is not a regular file; left untouched" >&2
+    fi
+  done
+  # Only once both are gone, and only if it is empty.
+  rmdir "${AGENTD_BIN_DIR}" 2>/dev/null || true
+  rm -f "${CLAUDE_DIR}/.luciazero-agentd-home"
+fi
+
 LEGACY_HANDOFF="${CLAUDE_DIR}/skills/handoff"
 if [ -f "${LEGACY_HANDOFF}/SKILL.md" ]; then
   if cmp -s "${SRC}/migrations/handoff-v1.5.0.SKILL.md" "${LEGACY_HANDOFF}/SKILL.md"; then
@@ -108,24 +216,61 @@ fi
 # files we just deleted.
 SETTINGS="${CLAUDE_DIR}/settings.json"
 HOOKS_CLEAN=1
-if [ -f "${SETTINGS}" ] && grep -qF "${CLAUDE_DIR}/hooks/luciazero-" "${SETTINGS}"; then
+# No `grep` gate. The installer quotes the path it writes, so a config
+# directory whose name contains an apostrophe is stored as
+# `'/home/config with '"'"' quote/hooks/luciazero-verify.sh' edit` -- the bare
+# path is not a substring of that, and a grep for it answered "nothing of ours
+# here" while the hook files were deleted anyway, leaving settings.json
+# pointing at files that no longer exist. Only the parser knows what is ours,
+# so the parser is asked whenever there is a file to ask about. It reports
+# three separate outcomes and never writes a backup it did not need:
+#   0  nothing of ours -- settings.json untouched
+#   10 ours found and removed -- backup written first
+#   *  read, parse or write failed -- settings.json is left exactly as it was
+if [ -f "${SETTINGS}" ]; then
   if command -v python3 >/dev/null 2>&1; then
-    cp "${SETTINGS}" "$(bakpath "${SETTINGS}")"
+    HOOKS_RC=0
     # exact-path matching only: never touch a user's own hook that merely
     # shares a basename with ours
-    if python3 - "${SETTINGS}" "${CLAUDE_DIR}" 2>/dev/null <<'PY'
-import json, os, sys
+    python3 - "${SETTINGS}" "${CLAUDE_DIR}" <<'PY' || HOOKS_RC=$?
+import json, os, shlex, shutil, sys, time
 
 path, claude_dir = sys.argv[1], sys.argv[2]
-with open(path) as f:
-    settings = json.load(f)
+try:
+    with open(path) as f:
+        settings = json.load(f)
+except (OSError, ValueError) as exc:
+    print("      " + str(exc), file=sys.stderr)
+    raise SystemExit(1)
+
+# settings.json is the user's file and may hold any JSON at all. A shape this
+# cannot walk is not "nothing of ours": it is a file we cannot prove clean, so
+# it stays as it is and the hook files stay with it.
+if not isinstance(settings, dict) or not isinstance(settings.get("hooks", {}), dict):
+    print("      settings.json is valid JSON but not the shape hooks live in",
+          file=sys.stderr)
+    raise SystemExit(1)
 
 MARKERS = (
     os.path.join(claude_dir, "hooks", "luciazero-verify.sh"),
     os.path.join(claude_dir, "hooks", "luciazero-statusline.sh"),
 )
 def ours(cmd):
-    return any(cmd == m or cmd.startswith(m + " ") for m in MARKERS)
+    """Both spellings of our own command, and nothing else.
+
+    The installer quotes the path now, so the bytes no longer start with it;
+    matching only the bare prefix would leave every entry it wrote behind,
+    still pointing at files this script is about to delete. The bare form
+    stays recognised because older installs wrote it -- including the broken
+    bare form with a space in it, which `shlex` cannot parse back.
+    """
+    if any(cmd == m or cmd.startswith(m + " ") for m in MARKERS):
+        return True
+    try:
+        parts = shlex.split(cmd)
+    except ValueError:
+        return False
+    return bool(parts) and parts[0] in MARKERS
 
 changed = False
 hooks = settings.get("hooks") or {}
@@ -153,23 +298,85 @@ if isinstance(sl, dict) and ours(sl.get("command", "")):
     del settings["statusLine"]
     changed = True
 
-if changed:
+if not changed:
+    raise SystemExit(0)
+
+# The user's file changes only once the new content is known, and only after a
+# complete copy of the old one exists beside it, under a name nothing else
+# holds.
+#
+# "Nothing else holds" cannot be asked with os.path.exists: it follows the
+# name, and answers False for a symlink whose target is missing. A dangling
+# symlink planted at the name this was about to take therefore read as free,
+# and the copy then followed it -- writing the user's settings outside the
+# config directory, under a name the planter chose, while the config directory
+# was left with no backup at all. O_CREAT|O_EXCL is the question that cannot
+# be fooled: the kernel refuses the open if anything is at the name, a
+# dangling symlink included, and refuses without following it. The name is
+# ours only once that open has returned, so the bytes go through that
+# descriptor and the name is never resolved a second time.
+stamp = time.strftime("%Y%m%d%H%M%S")
+backup, fd, n = path + ".bak." + stamp, None, 1
+while fd is None:
+    try:
+        fd = os.open(backup, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
+    except FileExistsError:
+        if n > 100:
+            print("      no free backup name beside " + os.path.basename(path),
+                  file=sys.stderr)
+            raise SystemExit(1)
+        backup = path + ".bak." + stamp + "." + str(n)
+        n += 1
+    except OSError as exc:
+        print("      " + str(exc), file=sys.stderr)
+        raise SystemExit(1)
+
+# A backup that is not complete is not a backup. If any part of making one
+# fails, the reserved file goes and settings.json is never opened for writing
+# -- which is the outcome that keeps the hook files, upstairs.
+try:
+    with open(path, "rb") as src, os.fdopen(fd, "wb") as dst:
+        fd = None  # fdopen owns it now, and closing it twice is an error
+        shutil.copyfileobj(src, dst)
+    shutil.copystat(path, backup)  # mode and times, the half copy2 adds
+except OSError as exc:
+    if fd is not None:
+        os.close(fd)
+    try:
+        os.unlink(backup)
+    except OSError:
+        pass
+    print("      " + str(exc), file=sys.stderr)
+    raise SystemExit(1)
+
+try:
     with open(path, "w") as f:
         json.dump(settings, f, indent=2, ensure_ascii=False)
         f.write("\n")
+except OSError as exc:
+    print("      " + str(exc), file=sys.stderr)
+    raise SystemExit(1)
+print("  ok  backup: " + os.path.basename(backup))
+raise SystemExit(10)
 PY
-    then
-      echo "  ok  removed hook entries from settings.json"
-    else
-      HOOKS_CLEAN=0
-      echo "  !!  could not clean settings.json (invalid JSON?) — hook files kept so nothing dangles; remove the luciazero-* entries manually, then delete ${CLAUDE_DIR}/hooks/luciazero-*.sh" >&2
-    fi
+    case "${HOOKS_RC}" in
+      0)
+        echo "  ok  no enforcement-pack entries in settings.json"
+        ;;
+      10)
+        echo "  ok  removed hook entries from settings.json"
+        ;;
+      *)
+        HOOKS_CLEAN=0
+        echo "  !!  could not clean settings.json (invalid JSON?) — hook files kept so nothing dangles; remove the luciazero-* entries manually, then delete ${CLAUDE_DIR}/hooks/luciazero-*.sh" >&2
+        ;;
+    esac
   else
     HOOKS_CLEAN=0
     echo "  !!  python3 not found — settings.json untouched; hook files kept so nothing dangles" >&2
   fi
 else
-  echo "  ok  no enforcement-pack entries in settings.json"
+  echo "  ok  no settings.json to clean"
 fi
 if [ "${HOOKS_CLEAN}" = 1 ]; then
   for H in luciazero-verify.sh luciazero-statusline.sh; do
@@ -187,15 +394,82 @@ fi
 
 if [ -f "${GLOBAL_MD}" ] && grep -qF "${IMPORT_LINE}" "${GLOBAL_MD}"; then
   BACKUP="$(bakpath "${GLOBAL_MD}")"
-  cp "${GLOBAL_MD}" "${BACKUP}"
-  # grep exits 1 when the import line was the only content — that is fine
-  grep -vxF "${IMPORT_LINE}" "${GLOBAL_MD}" > "${GLOBAL_MD}.tmp" || [ $? -eq 1 ]
-  mv "${GLOBAL_MD}.tmp" "${GLOBAL_MD}"
-  [ -s "${GLOBAL_MD}" ] || rm -f "${GLOBAL_MD}"
-  echo "  ok  removed import line (backup: $(basename "${BACKUP}"))"
+  cp -p "${GLOBAL_MD}" "${BACKUP}"
+  # `install.sh` appends the import line to an existing CLAUDE.md as
+  # `printf '\n%s\n'` — a blank separator and then the line — so removing only
+  # the line leaves the separator behind and every install-and-uninstall cycle
+  # grows a file the user wrote. Removing it is only safe where this
+  # installer is provably the one that put it there: the same file shape
+  # arises when somebody writes the import line themselves, and `install.sh`
+  # then leaves the file untouched, which makes the blank theirs. So the
+  # separator goes only on the record `install.sh` left behind, and the record
+  # carries the hash of the file as the installer left it, so it says something
+  # about THIS file and not merely about what the installer usually does. Move
+  # the import line, add a blank line, change a word: the hash stops matching
+  # and the separator stays. Any other value -- including none, which is every
+  # install older than this one, and every install that found a foreign
+  # `.luciazero-import` and refused to write -- takes the conservative path of
+  # removing the line and nothing else.
+  # BACKUP is the snapshot everything below reads: the hash is taken from it
+  # and the rewrite is computed from it, so the decision and the transform
+  # cannot see two different files. The live file is compared against that
+  # snapshot again before the result is published; anything that changed it in
+  # between wins, and this leaves it alone. A rename cannot be made atomic
+  # against an editor that is mid-write, so this narrows the window rather
+  # than closing it.
+  PROV="$(read_provenance)"
+  MD_TMP="$(mktemp "${CLAUDE_DIR}/.luciazero-claude-md.XXXXXX")"
+  # mktemp makes its file 0600 and the rename below publishes that file, so
+  # without this a 0640 CLAUDE.md came back 0600. Copying the backup -- which
+  # kept the original's mode -- onto the temporary file carries the mode over;
+  # the redirection that follows replaces the content and leaves it.
+  cp -p "${BACKUP}" "${MD_TMP}"
+  if [ "${PROV%% *}" = appended ] && [ -n "${PROV#appended }" ] \
+     && [ "${PROV#appended }" = "$(sha_of "${BACKUP}")" ]; then
+    awk -v want="${IMPORT_LINE}" '
+      $0 == want { pending = 0; next }
+      pending    { print ""; pending = 0 }
+      $0 == ""   { pending = 1; next }
+                 { print }
+      END        { if (pending) print "" }
+    ' "${BACKUP}" > "${MD_TMP}"
+  else
+    # grep exits 1 when the import line was the only content — that is fine
+    grep -vxF "${IMPORT_LINE}" "${BACKUP}" > "${MD_TMP}" || [ $? -eq 1 ]
+  fi
+  if cmp -s "${BACKUP}" "${GLOBAL_MD}"; then
+    mv "${MD_TMP}" "${GLOBAL_MD}"
+    [ -s "${GLOBAL_MD}" ] || rm -f "${GLOBAL_MD}"
+    IMPORT_REWRITTEN=1
+  else
+    rm -f "${MD_TMP}"
+    IMPORT_REWRITTEN=0
+    echo "  !!  CLAUDE.md changed while this was running; left exactly as it is now (backup: $(basename "${BACKUP}"))" >&2
+  fi
+  # A backup whose entire content is the line this installer wrote, on a
+  # CLAUDE.md that held nothing else, protects nothing: the machine had no
+  # CLAUDE.md before the install, and leaving the backup means it does not
+  # come back to that. Only this invocation's own BACKUP path is considered --
+  # never a glob, and never an older backup, whose identical content would
+  # still be somebody's decision to keep. One byte of anyone else's text and
+  # the file stays.
+  if [ "${IMPORT_REWRITTEN}" = 1 ]; then
+    if printf '%s\n' "${IMPORT_LINE}" | cmp -s - "${BACKUP}"; then
+      rm -f "${BACKUP}"
+      echo "  ok  removed import line (its backup held only that line; removed)"
+    else
+      echo "  ok  removed import line (backup: $(basename "${BACKUP}"))"
+    fi
+  fi
 else
   echo "  ok  no import line in CLAUDE.md"
 fi
+# Ours to remove only if it is ours, by the same marker install.sh wrote.
+# Anything else at this path -- a symlink, a directory, a regular file with
+# somebody's notes in it -- is left exactly where it is.
+if provenance_is_ours; then
+  rm -f "${IMPORT_PROVENANCE}"
+fi
 
 for KEEP in luciazero-stats.log luciazero-heuristics.md; do
   if [ -f "${CLAUDE_DIR}/${KEEP}" ]; then
@@ -206,5 +480,12 @@ if [ -d "${CLAUDE_DIR}/.luciazero-backups" ]; then
   echo "  kept .luciazero-backups/ (pre-existing or customized components) — review and delete manually when no longer needed"
 fi
 
+# Directories this installer is the reason for, leaf to root, by name and
+# never by glob. rmdir refuses a directory that still holds anything, so one
+# file of the user's own keeps its directory and everything above it.
+rmdir "${CLAUDE_DIR}/skills" "${CLAUDE_DIR}/agents" 2>/dev/null || true
+rmdir "${CLAUDE_DIR}" 2>/dev/null || true
+
 echo
 echo "Done. Other CLAUDE.md content was left untouched."
+echo "The Agent Bus state directory (~/.luciazero/agent-bus) is data and was not touched."