lobotomized-claude-code-update

Upgrades a lobotomized Claude Code install in two gated stages. Stage 1 reports

what would change and stops; Stage 2 performs the upgrade only after the user

explicitly approves. The split exists because the upgrade touches three

independently-versioned pieces plus an in-place binary patch - an unreviewed

surprise here leaves the user with a broken claude.

If the user has already seen a Stage 1 report in this conversation and approved

it, skip straight to Stage 2.

The stack

Three pieces, version-pinned to each other:

~/.tweakcc/system-prompts and ~/.tweakcc/system-reminders are symlinks into

the LCC clone. The patcher splices LCC's overrides into the CC binary's cli.js

with node /dist/index.mjs --apply.

Use skrabe's tweakcc-fixed only. The npm tweakcc-fixed package (a

different fork) and upstream Piebald-AI/tweakcc lack the inlineBlobOverrides

and systemReminderOverrides mechanisms that the LCC inline-*.md and

system-reminders/*.md overrides depend on - a different patcher silently

disables them.

LCC and tweakcc-fixed ship paired commits per CC release ("realign for CC

2.1.X" / "feat: support CC 2.1.X"). The latest CC version the stack supports is

the highest prompts-2.1.X.json in tweakcc-fixed's data/prompts/.

Stage 1 - Report (read-only)

Resolve the clone paths and gather state in one block. This makes no changes.

LCC=$(dirname "$(readlink ~/.tweakcc/system-prompts)")
TF=""
for d in ~/dev/tweakcc-fixed ~/tweakcc-fixed; do
  [ -d "$d/.git" ] && git -C "$d" remote get-url origin 2>/dev/null | grep -q 'skrabe/tweakcc-fixed' && TF="$d" && break
done
[ -z "$TF" ] && TF=$(find ~ -maxdepth 5 -type d -name tweakcc-fixed -not -path '*/node_modules/*' 2>/dev/null | while read -r d; do git -C "$d" remote get-url origin 2>/dev/null | grep -q 'skrabe/tweakcc-fixed' && echo "$d" && break; done)
echo "LCC=$LCC"; echo "TF=${TF:-NOT FOUND}"

echo "### CURRENT ###"
claude --version
echo "CC binaries on disk:"; ls ~/.local/share/claude/versions/ 2>/dev/null
echo "LCC HEAD:  $(git -C "$LCC" rev-parse --short HEAD) $(git -C "$LCC" log -1 --format='%s')"
echo "TF  HEAD:  $(git -C "$TF" rev-parse --short HEAD) $(git -C "$TF" log -1 --format='%s')"

echo "### LATEST ###"
echo "CC latest (Anthropic): $(npm view @anthropic-ai/claude-code version 2>/dev/null)"
git -C "$LCC" fetch origin --quiet; git -C "$TF" fetch origin --quiet
echo "LCC origin: $(git -C "$LCC" rev-parse --short origin/HEAD) $(git -C "$LCC" log -1 --format='%s' origin/HEAD)"
echo "TF  origin: $(git -C "$TF" rev-parse --short origin/main) $(git -C "$TF" log -1 --format='%s' origin/main)"
echo "Latest supported CC: $(git -C "$TF" ls-tree -r --name-only origin/main -- data/prompts/ | grep -oE '2\.1\.[0-9]+' | sort -V | tail -1)"

echo "### DELTA ###"
echo "LCC behind: $(git -C "$LCC" rev-list --count HEAD..origin/HEAD) commits"
echo "TF  behind: $(git -C "$TF" rev-list --count HEAD..origin/main) commits"
echo "Override file changes (LCC):"
git -C "$LCC" diff --stat HEAD origin/HEAD -- system-prompts/ system-reminders/ | tail -40

echo "### BLOCKERS ###"
echo "LCC local-only commits: $(git -C "$LCC" rev-list --count origin/HEAD..HEAD)"
echo "TF  local-only commits: $(git -C "$TF" rev-list --count origin/main..HEAD)"
echo "LCC working tree:"; git -C "$LCC" status --short
echo "TF  working tree:"; git -C "$TF" status --short
echo "Stale apply cache:"; ls -la ~/.tweakcc/native-binary.backup ~/.tweakcc/native-claudejs-orig.js ~/.tweakcc/native-claudejs-patched.js 2>/dev/null || echo "  (none - clean)"
echo "latest symlink:"; ls -la ~/.local/state/claude/latest 2>/dev/null || echo "  (absent)"

Then present this report and stop:

## tweakcc stack upgrade - Stage 1 report

| Piece          | Current | Target | Behind     |
|----------------|---------|--------|------------|
| Claude Code    | <ver>   | <ver>  | -          |
| LCC overrides  | <sha>   | <sha>  | <N> commits|
| tweakcc-fixed  | <sha>   | <sha>  | <N> commits|

Target CC version: <the latest supported CC version>

What changes: <summary of override files added / removed / modified, from the diff --stat>

Blockers: <list, or "none">

Recommendation: <proceed | already up to date | resolve blockers first>

Decide the target CC version as the latest supported CC version (highest

prompts-2.1.X.json), provided Anthropic's npm latest is at or above it. If

the stack is already at target and 0 commits behind, say so - nothing to do.

Read git status --short carefully: untracked system-reminders/*.md files are

expected (Stage 2 handles them), but **local-only commits or uncommitted edits

to tracked files are real blockers** - surface them and do not plan to discard

them.

**Stop here. Present the report and wait for the user to explicitly approve

before doing anything in Stage 2.**

Stage 2 - Upgrade (only after explicit approval)

Re-run the resolve block from Stage 1 first so $LCC and $TF are set (shell

state does not persist between commands - use the resolved absolute paths in

every step below).

Pre-flight. If either repo has local-only commits or uncommitted changes to

tracked files, stop and ask the user how to handle them. Never force or discard.

1. Clear the stale apply cache. The patcher caches a pristine snapshot of

the CC binary. If that snapshot is from an older CC version, --apply writes

old-version-derived content into the new binary and corrupts it. Remove the

cache so the patcher re-snapshots the fresh binary:

```bash

rm -f ~/.tweakcc/native-binary.backup ~/.tweakcc/native-claudejs-orig.js ~/.tweakcc/native-claudejs-patched.js

```

1. Back up and clear untracked override files. The patcher auto-seeds

system-reminders/*.md (including per-MCP-server files) on --apply. Because

that directory is symlinked into the LCC clone, those files show up as

untracked and will block git pull once upstream tracks same-named files.

They re-seed on the next --apply, so back them up and clear them:

```bash

cp -R "$LCC/system-reminders/" /tmp/tweakcc-upgrade-backup-system-reminders/

git -C "$LCC" clean -fd -- system-reminders/

```

1. Install the target CC binary (pristine; may prompt for network/auth):

```bash

claude install

```

1. Update the repos. Both must fast-forward cleanly:

```bash

git -C "$LCC" pull --ff-only

git -C "$TF" pull --ff-only

pnpm --dir "$TF" install && pnpm --dir "$TF" build

```

1. Re-apply the overrides:

```bash

node "$TF/dist/index.mjs" --apply

```

Read the output. A clean run reports per-prompt char savings and no errors.

Any error or a complaint about a missing prompt means the override set and

the CC binary version are out of sync - stop and investigate, do not ignore it.

1. Check the latest symlink. The CC launcher resolves

~/.local/state/claude/latest; if it points at a version that is not on

disk, it silently falls back to newest-by-mtime. Confirm it points at the

target version under ~/.local/share/claude/versions/, and repoint it if not.

1. Verify:

```bash

claude --version

claude --print "say hello"

```

claude --version should report the target CC version. The current session

still runs the old binary - tell the user to relaunch claude to pick up the

upgrade.

Finish with a short summary: old -> new CC version, both repo SHAs moved, apply

result, and the relaunch reminder.

Why the guardrails matter

• Stale apply cache is the highest-severity footgun - it produces a binary

that reports the wrong version and behaves like an older CC. Always clear it

before --apply on a version bump.

• Untracked system-reminders/ files are harmless in themselves (they

re-seed), but they will hard-block git pull --ff-only. Clearing them is the

fix; the backup is just a safety net.

• --ff-only keeps the upgrade honest: if a repo cannot fast-forward, there

is local divergence that needs a human decision, not an automatic merge.

• Re-apply is mandatory after every CC binary change - a fresh `claude

install is pristine and carries none of the overrides until --apply` runs.