@amsterdamdatalabs/adl-agent-control-darwin-arm64 0.1.4

package/bin/lean-ctx-observe-strip

@@ -0,0 +1,361 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+export PATH="/usr/local/bin:/opt/homebrew/bin:/home/linuxbrew/.linuxbrew/bin:/usr/bin:/bin:/usr/sbin:/sbin"
+
+# lean-ctx-observe-strip -- the per-device half of STATUS.md 12p item 13.
+# Final scope (2026-09-29, Tarun, relayed through the orchestrator; see
+# bin/lib/lean-ctx-observe-hooks.sh's header for the full decision trail):
+# lean-ctx hooks are "moved to repo level" and must be REMOVED FROM GLOBAL --
+# the per-repo carrier (`adl hook lean-ctx pre-tool-use|post-tool-use`,
+# written by `adl hooks deploy`) already provides rewrite/redirect/
+# read-dedup with the repo's own config, and `observe` has no per-repo
+# carrier at all and is dropped outright. Five carriers, all written by
+# `lean-ctx setup`, are covered ("fix all the lean-ctx issues" -- Tarun,
+# 2026-09-29 -- widened this from an initial two-of-five scope):
+#   1. Raw, unwrapped `lean-ctx hook <subcommand>` entries -- observe,
+#      rewrite, redirect, read-dedup, any other -- in the two JSON
+#      hook-map files that can carry one: $HOME/.claude/settings.json and
+#      $HOME/.codex/hooks.json.
+#   2. The universal shell hook marker block (`# >>> lean-ctx shell hook
+#      >>>` ... `# <<< lean-ctx shell hook <<<`).
+#   3. `~/.zshrc`'s own differently-shaped shell hook block (an em dash,
+#      not `>>>`/`<<<`): `# lean-ctx shell hook — begin` ... `... — end`,
+#      sourcing a separate `~/.config/lean-ctx/shell-hook.zsh`.
+#   4. The agent-launcher aliases block: `# >>> lean-ctx agent aliases
+#      >>>` ... `# <<< lean-ctx agent aliases <<<`.
+#   Shapes 2-4 are all matched in the per-user shell rc/env files they can
+#   appear in: $HOME/.bashenv, .zshenv, .bashrc, .zshrc, .bash_profile,
+#   .zprofile, .profile -- see bin/lib/lean-ctx-observe-hooks.sh's header
+#   for exactly which marker text each shape matches, its trailing-
+#   whitespace tolerance, and its malformed-nesting/near-miss detection.
+#   5. Global lean-ctx SKILL.md directories (frontmatter `name: lean-ctx`)
+#      at $HOME/.claude/skills/lean-ctx, .codex/skills/lean-ctx,
+#      .cursor/skills/lean-ctx, .config/opencode/skills/lean-ctx,
+#      .agents/skills/lean-ctx.
+# `adl hook lean-ctx ...` (the per-repo carrier) and Orca's own hooks are
+# never touched -- see bin/lib/lean-ctx-observe-hooks.sh's own header for
+# exactly why the match can never catch either, and for the full "which
+# files can carry this, and why the others can't" accounting. `~/.config/
+# lean-ctx/` itself (which shape 3 sources) is deliberately left alone --
+# Tarun uses the global CLI directly from his own terminal -- flagged in
+# that same header, not stripped. Run by bin/reconcile on every
+# reconciliation (plan AND apply, exactly like bin/kimi-hooks /
+# bin/opencode-hooks) so a hand-edited or Orca-reinstalled per-user config
+# never lets any of the five carriers creep back in unnoticed.
+#
+# Usage: lean-ctx-observe-strip --home ABSOLUTE_PATH --mode plan|apply
+#
+#   plan:  READ-ONLY. Prints what apply would do; never writes, never backs
+#          up. A second run (plan or apply) against an already-clean home is
+#          a no-op.
+#   apply: For each target that still carries its carrier, backs it up
+#          first (same "<path>.pre-<label>-<UTC compact timestamp>" shape
+#          every other backup in this codebase uses -- bin/reconcile's own
+#          strip_backup_suffix recovers the original path from it, except
+#          for a skill directory's backup, which sits OUTSIDE the scanned
+#          skills/ tree and is reported via its own explicit two-path
+#          note; see strip_skill_dir_one below and final review finding
+#          1), then rewrites/moves it via the shared
+#          bin/lib/lean-ctx-observe-hooks.sh helpers. A JSON file that
+#          fails to parse, a shell file with a malformed marker (unclosed,
+#          nested, orphaned, or a near-miss mention of the marker phrase
+#          that doesn't exactly match a known marker line), is a loud
+#          failure (non-zero exit, nothing written) -- never a silent skip
+#          or a partial edit. A target with nothing to strip, or that does
+#          not exist, is reported and left alone. A skill directory is
+#          moved (never deleted) only when its SKILL.md frontmatter says
+#          `name: lean-ctx`; any other content there is left alone and
+#          reported. Refuses outright (before touching anything) when run
+#          as literal root (EUID 0) against a --home it does not own --
+#          bin/reconcile's apply path never does this itself; see
+#          lean_ctx_observe_strip_guard_euid in the shared lib.
+
+script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+command -v jq >/dev/null 2>&1 || {
+  echo "lean-ctx-observe-strip requires jq" >&2
+  exit 1
+}
+
+# shellcheck source=lib/lean-ctx-observe-hooks.sh
+source "$script_dir/lib/lean-ctx-observe-hooks.sh"
+
+usage() {
+  echo "usage: lean-ctx-observe-strip --home ABSOLUTE_PATH --mode plan|apply" >&2
+  exit 2
+}
+
+home=""
+mode=""
+while [[ "$#" -gt 0 ]]; do
+  case "$1" in
+    --home) home="${2:-}"; shift 2 ;;
+    --mode) mode="${2:-}"; shift 2 ;;
+    *) usage ;;
+  esac
+done
+[[ -n "$home" ]] || usage
+[[ "$mode" == plan || "$mode" == apply ]] || usage
+
+# Final review finding 5: refuse before touching anything if this is a
+# literal-root (EUID 0) invocation against a --home it does not own -- see
+# lean_ctx_observe_strip_guard_euid's own header for exactly why this can
+# never fire on bin/reconcile's real apply path (macOS: already dropped to
+# the administrator; Linux: administrator IS root, home IS /root).
+lean_ctx_observe_strip_guard_euid "$EUID" "$home" || exit 1
+
+# backup_file_safely <path> <backup> -- creates <backup> (a brand-new path)
+# holding a copy of <path>'s content and mode, WITHOUT ever following a
+# pre-existing file or symlink that happens to already sit at <backup>
+# (final review finding 5: a predictable, timestamp-based backup path
+# could be pre-planted by an attacker with write access to the same
+# directory; a plain `cp -p "$path" "$backup"` FOLLOWS an existing
+# symlink there and overwrites whatever it points at). `set -C`
+# (noclobber) reserves the name atomically first -- verified live, not
+# assumed: refuses to open `>` through both a valid and a dangling
+# pre-existing symlink at that exact path, on this machine's real bash,
+# leaving the symlink's target completely untouched either way -- and only
+# once that empty placeholder is confirmed OURS does `cp -p` fill it in.
+backup_file_safely() {
+  local path="$1" backup="$2"
+  if ! ( set -C; : > "$backup" ) 2>/dev/null; then
+    return 1
+  fi
+  cp -p "$path" "$backup"
+}
+
+# The two per-user JSON hook-map files that can carry a raw
+# `lean-ctx hook <subcommand>` entry -- see bin/lib/lean-ctx-observe-hooks.sh's
+# header for the read-only accounting of every other per-user agent config
+# file this machine has, and why each of those is NOT a target.
+targets=(
+  "$home/.claude/settings.json"
+  "$home/.codex/hooks.json"
+)
+
+# The per-user shell rc/env files `lean-ctx setup` can write any of the
+# three shell-hook marker shapes into (confirmed live: .zshenv and
+# .bashenv both carry shape 2 after a real `lean-ctx setup` run, .zshrc
+# carries shapes 3 and 4; the others are included because the same
+# installer step targets the whole rc/env family).
+shell_hook_targets=(
+  "$home/.bashenv"
+  "$home/.zshenv"
+  "$home/.bashrc"
+  "$home/.zshrc"
+  "$home/.bash_profile"
+  "$home/.zprofile"
+  "$home/.profile"
+)
+
+# The global lean-ctx SKILL.md directories `lean-ctx setup` can write, one
+# per agent surface it detects (confirmed live for Claude/Codex/OpenCode;
+# Cursor and .agents included for the same reason as above -- the
+# installer targets the whole surface family, not just the ones detected
+# on any one machine).
+skill_dir_targets=(
+  "$home/.claude/skills/lean-ctx"
+  "$home/.codex/skills/lean-ctx"
+  "$home/.cursor/skills/lean-ctx"
+  "$home/.config/opencode/skills/lean-ctx"
+  "$home/.agents/skills/lean-ctx"
+)
+
+strip_one() {
+  local path="$1"
+  if [[ ! -f "$path" ]]; then
+    echo "lean-ctx-observe-strip: $path: not present -- nothing to strip"
+    return 0
+  fi
+  local events
+  if ! events="$(lean_ctx_observe_hook_events "$path")"; then
+    echo "lean-ctx-observe-strip: $path: FAILED to parse as JSON -- not modified" >&2
+    return 1
+  fi
+  if [[ -z "$events" ]]; then
+    echo "lean-ctx-observe-strip: $path: no raw lean-ctx hook entries found"
+    return 0
+  fi
+  echo "lean-ctx-observe-strip: $path: found raw lean-ctx hook entries under: $events"
+  if [[ "$mode" != apply ]]; then
+    echo "lean-ctx-observe-strip: would strip raw lean-ctx hook entries from $path (events: $events)"
+    return 0
+  fi
+  local backup
+  backup="${path}.pre-lean-ctx-observe-strip-$(date -u +%Y%m%dT%H%M%SZ)"
+  if ! backup_file_safely "$path" "$backup"; then
+    echo "lean-ctx-observe-strip: backup of $path to $backup did not complete -- $path was NOT modified" >&2
+    return 1
+  fi
+  echo "lean-ctx-observe-strip: backed up previous config to $backup"
+  local staged
+  staged="$(mktemp "$(dirname "$path")/.$(basename "$path").filtered.XXXXXX" 2>/dev/null)" || {
+    echo "lean-ctx-observe-strip: $path: FAILED to allocate staging file -- not modified (backup: $backup)" >&2
+    return 1
+  }
+  if ! lean_ctx_observe_hook_filtered "$path" "$staged"; then
+    echo "lean-ctx-observe-strip: $path: FAILED to compute filtered content -- not modified (backup: $backup)" >&2
+    rm -f "$staged"
+    return 1
+  fi
+  if ! lean_ctx_observe_hook_write "$path" "$staged"; then
+    echo "lean-ctx-observe-strip: $path: FAILED to write -- not modified (backup: $backup)" >&2
+    rm -f "$staged"
+    return 1
+  fi
+  rm -f "$staged"
+  echo "lean-ctx-observe-strip: stripped raw lean-ctx hook entries from $path (backup: $backup)"
+  return 0
+}
+
+# strip_shell_hook_one <path> -- covers all THREE shell-hook marker shapes
+# bin/lib/lean-ctx-observe-hooks.sh's header documents, via ONE single-pass
+# call to lean_ctx_shell_rc_scan_and_filter: one backup, one write, never
+# one per shape, even for a file (a real `~/.zshrc`) carrying more than
+# one. Malformed input in ANY shape (unclosed, nested, orphaned, or a
+# near-miss marker-phrase mention) aborts before any write, with the
+# backup only ever created once something is confirmed found.
+strip_shell_hook_one() {
+  local path="$1"
+  if [[ ! -f "$path" ]]; then
+    echo "lean-ctx-observe-strip: $path: not present -- nothing to strip"
+    return 0
+  fi
+
+  local staged report
+  staged="$(mktemp "$(dirname "$path")/.$(basename "$path").filtered.XXXXXX" 2>/dev/null)" || {
+    echo "lean-ctx-observe-strip: $path: FAILED to allocate staging file -- not modified" >&2
+    return 1
+  }
+  report="$(mktemp "$(dirname "$path")/.$(basename "$path").report.XXXXXX" 2>/dev/null)" || {
+    echo "lean-ctx-observe-strip: $path: FAILED to allocate report file -- not modified" >&2
+    rm -f "$staged"
+    return 1
+  }
+
+  if ! lean_ctx_shell_rc_scan_and_filter "$path" "$staged" "$report"; then
+    echo "lean-ctx-observe-strip: $path: FAILED -- see the malformed-marker message above -- not modified" >&2
+    rm -f "$staged" "$report"
+    return 1
+  fi
+
+  local found1=absent found2=absent found3=absent line
+  while IFS= read -r line; do
+    case "$line" in
+      1:*) found1="${line#1:}" ;;
+      2:*) found2="${line#2:}" ;;
+      3:*) found3="${line#3:}" ;;
+    esac
+  done < "$report"
+  rm -f "$report"
+
+  [[ "$found1" == present ]] && echo "lean-ctx-observe-strip: $path: found lean-ctx shell hook marker block" \
+    || echo "lean-ctx-observe-strip: $path: no lean-ctx shell hook marker found"
+  [[ "$found2" == present ]] && echo "lean-ctx-observe-strip: $path: found lean-ctx shell hook marker block (zshrc begin/end form)" \
+    || echo "lean-ctx-observe-strip: $path: no lean-ctx shell hook marker (zshrc begin/end form) found"
+  [[ "$found3" == present ]] && echo "lean-ctx-observe-strip: $path: found lean-ctx agent aliases marker block" \
+    || echo "lean-ctx-observe-strip: $path: no lean-ctx agent aliases marker found"
+
+  if [[ "$found1" != present && "$found2" != present && "$found3" != present ]]; then
+    rm -f "$staged"
+    return 0
+  fi
+
+  if [[ "$mode" != apply ]]; then
+    [[ "$found1" == present ]] && echo "lean-ctx-observe-strip: would strip lean-ctx shell hook marker block from $path"
+    [[ "$found2" == present ]] && echo "lean-ctx-observe-strip: would strip lean-ctx shell hook marker block (zshrc begin/end form) from $path"
+    [[ "$found3" == present ]] && echo "lean-ctx-observe-strip: would strip lean-ctx agent aliases marker block from $path"
+    rm -f "$staged"
+    return 0
+  fi
+
+  local backup
+  backup="${path}.pre-lean-ctx-observe-strip-$(date -u +%Y%m%dT%H%M%SZ)"
+  if ! backup_file_safely "$path" "$backup"; then
+    echo "lean-ctx-observe-strip: backup of $path to $backup did not complete -- $path was NOT modified" >&2
+    rm -f "$staged"
+    return 1
+  fi
+  echo "lean-ctx-observe-strip: backed up previous config to $backup"
+
+  if ! lean_ctx_observe_hook_write "$path" "$staged"; then
+    echo "lean-ctx-observe-strip: $path: FAILED to write -- not modified (backup: $backup)" >&2
+    rm -f "$staged"
+    return 1
+  fi
+  rm -f "$staged"
+
+  [[ "$found1" == present ]] && echo "lean-ctx-observe-strip: stripped lean-ctx shell hook marker block from $path (backup: $backup)"
+  [[ "$found2" == present ]] && echo "lean-ctx-observe-strip: stripped lean-ctx shell hook marker block (zshrc begin/end form) from $path (backup: $backup)"
+  [[ "$found3" == present ]] && echo "lean-ctx-observe-strip: stripped lean-ctx agent aliases marker block from $path (backup: $backup)"
+  return 0
+}
+
+# strip_skill_dir_one <dir> -- final review finding 1 (HIGH): the backup
+# location is a SIBLING of the scanned `skills/` directory
+# (`<surface>/skills.pre-lean-ctx-observe-strip-<ts>/<leaf>`), never a path
+# INSIDE it. The previous shape (`skills/<leaf>.pre-...-<ts>`) left the
+# moved directory's own SKILL.md -- frontmatter `name: lean-ctx` and all --
+# still sitting directly under `skills/`, where any surface that globs
+# `skills/*/SKILL.md` by frontmatter name would load it right back up as a
+# live skill; the whole point of "moved, never deleted" was to make it
+# INERT, not just renamed. Reported via its own explicit two-path "backed
+# up previous skill directory <original> to <backup>" note (distinct from
+# the single-path "backed up previous config to <path>" the JSON/shell-hook
+# carriers use) because the new backup path no longer ends in
+# `.pre-<label>-<timestamp>` -- bin/reconcile's suffix-stripping
+# strip_backup_suffix can't recover the original from it, so the original
+# is stated directly instead; see bin/reconcile's
+# collect_lean_ctx_observe_strip_backups.
+strip_skill_dir_one() {
+  local dir="$1"
+  if [[ ! -e "$dir" ]]; then
+    echo "lean-ctx-observe-strip: $dir: not present -- nothing to strip"
+    return 0
+  fi
+  local skill_md="$dir/SKILL.md"
+  if [[ ! -f "$skill_md" ]]; then
+    echo "lean-ctx-observe-strip: $dir: present but has no SKILL.md -- left alone"
+    return 0
+  fi
+  local name
+  name="$(lean_ctx_skill_frontmatter_name "$skill_md")"
+  if [[ "$name" != "$LEAN_CTX_SKILL_FRONTMATTER_NAME" ]]; then
+    echo "lean-ctx-observe-strip: $dir: SKILL.md frontmatter name is '${name:-<none>}', not lean-ctx -- left alone"
+    return 0
+  fi
+  echo "lean-ctx-observe-strip: $dir: found lean-ctx skill directory (SKILL.md name: lean-ctx)"
+  if [[ "$mode" != apply ]]; then
+    echo "lean-ctx-observe-strip: would move $dir to a timestamped backup location outside the scanned skills/ directory"
+    return 0
+  fi
+  local skills_dir leaf backup_root backup
+  skills_dir="$(dirname "$dir")"
+  leaf="$(basename "$dir")"
+  backup_root="${skills_dir}.pre-lean-ctx-observe-strip-$(date -u +%Y%m%dT%H%M%SZ)"
+  backup="$backup_root/$leaf"
+  if ! mkdir "$backup_root" 2>/dev/null; then
+    echo "lean-ctx-observe-strip: $dir: FAILED to create backup location $backup_root -- not modified" >&2
+    return 1
+  fi
+  if ! mv "$dir" "$backup"; then
+    echo "lean-ctx-observe-strip: $dir: FAILED to move to $backup -- not modified" >&2
+    return 1
+  fi
+  echo "lean-ctx-observe-strip: backed up previous skill directory $dir to $backup"
+  echo "lean-ctx-observe-strip: moved lean-ctx skill directory $dir to $backup"
+  return 0
+}
+
+status=0
+for target in "${targets[@]}"; do
+  strip_one "$target" || status=1
+done
+for target in "${shell_hook_targets[@]}"; do
+  strip_shell_hook_one "$target" || status=1
+done
+for target in "${skill_dir_targets[@]}"; do
+  strip_skill_dir_one "$target" || status=1
+done
+exit "$status"

package/bin/lib/bun-compile-build.sh

@@ -0,0 +1,34 @@
+# Shared bun-compile build step, sourced by bin/reconcile and by
+# tests/test-manifest.sh (which sources this file directly to exercise it
+# with a stub $bun_bin -- no root, no network, no full reconcile run).
+#
+# bun's `--compile` step always drops a multi-megabyte `*.bun-build` scratch
+# file next to its CWD, regardless of where --outfile points -- an open,
+# unfixed bun bug that still reproduces on 1.4.2:
+# https://github.com/oven-sh/bun/issues/14020. Reconcile's bun-compile
+# manager used to compile with CWD set to the source checkout, which left
+# that scratch file untracked in the canonical checkout on every scheduled
+# run. Before the forced sync replaced refusal (observed 2026-09-15), that made
+# the then-current dirty-checkout guard abort reconciliation.
+#
+# So the compile always runs with CWD set to a throwaway `mktemp -d`, never
+# the source checkout, inside a subshell whose own EXIT trap removes that
+# directory on any exit -- success, a failed build, or a signal -- without
+# touching traps anywhere else in the calling script. The compiled binary is
+# copied out to "$target.new" and only then renamed onto "$target", so a
+# failed or interrupted build never clobbers a working binary.
+bun_compile_build() {
+  local bun_bin="$1"
+  local entry_path="$2"
+  local target="$3"
+  [[ -f "$entry_path" ]] || { echo "bun-compile entry missing: $entry_path" >&2; exit 1; }
+  (
+    build_dir="$(mktemp -d)"
+    trap 'rm -rf "$build_dir"' EXIT
+    cd "$build_dir"
+    "$bun_bin" build --compile "$entry_path" --outfile "$build_dir/out"
+    chmod 0755 "$build_dir/out"
+    cp "$build_dir/out" "$target.new"
+  )
+  mv "$target.new" "$target"
+}