# Återställa Claude Code: säkert läge, /cd och reservmodell
> Felsök Claude Code med säkert läge, kommandot /cd, reservmodeller och återställning av inställningar. Kontrollerna i rätt ordning och de ursprungliga begränsningarna.
Source: https://ailoot.ai/blog/sv/claude-code-safe-mode-recovery/
Canonical: https://ailoot.ai/blog/sv/claude-code-safe-mode-recovery/
Language: sv
Publisher: Ailoot (https://ailoot.ai/)
Translation: guide-140
Revision: sha256-de2fde90e80e83923a51fcb0f638ae6f99bf7d870c7a0335e7131e27885a7b3e
Praktiskt material om att arbeta med agenter: [Ailoot-dokumentation](https://ailoot.ai/docs/).
## Vad förändras i Claude Code i juni 2026?
Det viktigaste
Den 8 juni 2026 lade Anthropic till flaggan `--safe-mode` och kommandot `/cd` i Claude Code v2.1.169. Två dagar tidigare introducerades reservmodeller i v2.1.166, upp till 3 i en kedja. De här tre funktionerna åtgärdar det vanligaste problemet för vibe-kodare: ”allt har slutat fungera, jag vet inte vad som är fel och jag vill inte förlora en timme på att installera om.”
Tidigare fanns det bara en utväg när Claude Code började bete sig konstigt – en oändlig laddningssnurra, en krasch vid start, agenten som ignorerade regler i `CLAUDE.md` eller en hook som inte kördes utan att säga till: kommentera manuellt bort delar av `.claude/settings.json`, inaktivera MCP-servrar en i taget eller, i värsta fall, radera `~/.claude` och installera om. I ett beskrivet fall raderades `~/.claude`, och MCP-serverkonfigurationen som hade tagit en och en halv timme att sätta ihop gick förlorad. Senare visade det sig att en rad i `CLAUDE.md` var boven och kunde ha hittats på 10 sekunder – men det blev tydligt först efter en fullständig återställning.
I juni 2026 rullade Anthropic ut tre mekanismer som förändrar det här scenariot. Kortfattat: vad som kom och när:
| Version | Datum | Nyheter |
|----|----|----|
| **2.1.166** | 6 juni 2026 | Inställningen `fallbackModel` + flaggan `--fallback-model` för interaktiva sessioner |
| **2.1.169** | 8 juni 2026 | Flaggan `--safe-mode` och miljövariabeln `CLAUDE_CODE_SAFE_MODE`, kommandot `/cd` |
| **2.1.176** | 12 juni 2026 | Fix: `/cd` och växling av worktree slutade visa den gamla git-grenen |
Nedan förklaras varje mekanism steg för steg, tillsammans med i vilken ordning du bör använda dem när en Claude Code-session hamnar på avvägar.
## Vad får oftast Claude Code att sluta fungera?
Det viktigaste
Utifrån den beskrivna erfarenheten slutar Claude Code oftast fungera för vibe-kodare på grund av fyra saker: en överlastad `CLAUDE.md` med motstridiga regler, en hook med felaktig slutkod, en MCP-server som misslyckas tyst och överlappande inställningar på tre nivåer i `settings.json`. Det finns en bov, felsökningen tar några minuter, men panik får folk att ta till `rm -rf` direkt.
I det beskrivna exemplet sattes `CLAUDE.md` först ihop på 80 rader – och det fungerade i en månad. Under den andra månaden började det märkas att Claude en gång i veckan bröt mot alla regler som hade satts upp: rörde `.env`, körde `git push --force`, rotade runt i `node_modules`. Inte avsiktligt – den glömde helt enkelt. En gång raderades `.gitignore`, och orsaken var inte omedelbart tydlig. Scenariot behandlas mer ingående i [guiden om `CLAUDE.md`](https://ailoot.ai/blog/sv/claude-md-template/).
När `CLAUDE.md` växer till 400+ rader börjar den skapa problem i det tysta: den tar upp en betydande del av kontextfönstret när sessionen startar och späder ut viktiga instruktioner med mindre viktiga. Claude läser fortfarande formellt filen, så utifrån ser det ut som ”reglerna finns där, men de fungerar inte” – ett typiskt tecken på ett överlastat avtal.
Hooks är den näst vanligaste felkällan. `Claude Code hooks` har en egenhet som Anthropic inte betonar.
Det innebär att `sys.exit(1)` i en Python-hook (eller något annat Unix-konventionellt ”misslyckades med ett fel”) inte stoppar Claude. Endast kod `2` är blockerande. I det beskrivna fallet betraktades hooken som ett ”absolut förbud”, men i praktiken loggade den ett klagomål och tillät åtgärden.
MCP-servrar är det tredje lagret, och de kan också fallera på sitt eget sätt.
Symptomet ser ofta likadant ut: MCP-kommandon är tillgängliga men returnerar `failed` utan en stacktrace. Mer om att konfigurera MCP och lägga till servrar med `claude mcp add` finns i [den separata guiden](https://ailoot.ai/blog/sv/mcp-servers-claude-code/).
Den fjärde felkällan är den hierarki med tre nivåer som `settings.json` har. Du har `~/.claude/settings.json` (användarnivå), `.claude/settings.json` i projektets rot (projekt), `.claude/settings.local.json` (lokalt) och eventuellt hanterade inställningar från en företagsadministratör. De slås samman enligt prioritetsregler. När någon lägger till en MCP-server på projektnivå samtidigt som du har en liknande post med en annan startkonfiguration på användarnivå uppstår en tyst konflikt, som ser ut som att ”Claude Code är trasigt”.
## Hur fungerar `--safe-mode`, och vad inaktiverar det?
Det viktigaste
`claude --safe-mode` startar Claude Code med anpassningar helt inaktiverade: `CLAUDE.md`, plugins, skills, hooks, MCP-servrar, användarkommandon, agenter, utdataformat, arbetsflöden och tangentbindningar. Auktorisering, modellval, inbyggda verktyg och behörigheter finns kvar. Det här är ett diagnosverktyg: om problemet försvinner i säkert läge är en av de anpassningar du lagt till boven.
Anthropics ursprungliga formulering i ändringsloggen för v2.1.169 lyder:
Lade till flaggan --safe-mode (och CLAUDE_CODE_SAFE_MODE) för att starta Claude Code med anpassningar inaktiverade (CLAUDE.md, plugins, skills, hooks, MCP-servrar) för diagnostik.
— Anthropic Claude Code – ändringslogg, https://code.claude.com/docs/en/changelog
Anthropic förtydligar i dokumentationen om modellkonfiguration:
För att kontrollera om anpassningarna är boven startar du en session med claude --safe-mode, vilket inaktiverar CLAUDE.md, skills, MCP-servrar och hooks. Git-status och katalognamn räknas inte som anpassningar och är fortsatt tillgängliga.
— Anthropic-dokumentation – modellkonfiguration, https://code.claude.com/docs/en/model-config
Det här är ett **diagnosverktyg**, inte en ”ren miljö”. Säkert läge hjälper dig att besvara en fråga: ligger problemet i Claude Codes standardbeteende eller i de anpassningar som lagts till? Det här är en del av kontextteknik – att hantera vad Claude ser och inte ser vid varje given tidpunkt. Om allt fungerar i säkert läge är det tydligt att lagren behöver kontrolleras med binärsökning. Om det inte fungerar ligger problemet i själva installationen, auktoriseringen, nätverket eller infrastrukturen, och då är det rimligt att titta på `claude doctor` och loggarna.
Det här inaktiverar säkert läge (Anthropics officiella lista – 5 huvudlager):
- `CLAUDE.md` på alla nivåer (användare / projekt)
- Plugins
- Skills
- Hooks
- MCP-servrar
Det här fortsätter att fungera:
- Auktorisering (din OAuth-session eller API-nyckel)
- Modellval (`--model sonnet`, `--model opus`)
- Inbyggda verktyg (Read, Write, Bash, Grep och så vidare)
- Behörigheter
- Git-status
- Katalognamn
En viktig detalj: säkert läge inaktiverar inte hanterade/policyinställningar från en företagsadministratör. Om du arbetar i ett team där Bedrock GovCloud eller en MDM-konfiguration anger `availableModels`, gäller de begränsningarna fortfarande – säkert läge inaktiverar endast dina anpassningar, inte företagspolicyer.
## Hur isolerar du ett lager och hittar boven på 60 sekunder?
Det viktigaste
Steg 1: kör `claude --safe-mode` i samma mapp där problemen uppstod. Om det fungerar ligger problemet i dina anpassningar, och då aktiverar du dem en i taget: `CLAUDE.md` -> hooks -> MCP -> skills. Om det inte fungerar ens i säkert läge ligger problemet i auth, versionen, nätverket eller operativsystemet. Kör i så fall `claude doctor` för automatisk diagnostik, utan att röra `rm -rf`.
Ett felsökningsscenario för när Claude Code har ”slutat lyssna”. Den lägsta versionen för alla kommandon nedan är **Claude Code v2.1.169**. Om din version är äldre uppdaterar du först (`npm update -g @anthropic-ai/claude-code` eller Anthropics inbyggda installationsprogram).
1. Öppna samma mapp där problemen uppstod.
2. Kör `claude --safe-mode`.
3. Om programmet startar utan problem kontrollerar du din ursprungliga begäran. Fungerade den? Då ligger problemet i ett av lagren. Gå till steg 4.
4. Om det fortfarande inte fungerar i säkert läge ska du inte röra konfigurationerna. Kör först `claude doctor`; kontrollera auth, version och motstridiga installationer.
När säkert läge startar utan problem aktiverar du lagren ett i taget, med den mest sannolika boven först. Ordningen utgår från den beskrivna erfarenheten:
1. **`CLAUDE.md`.** Kör `claude` utan säkert läge, men byt tillfälligt namn på filen: `mv CLAUDE.md CLAUDE.md.bak`. Om det fungerar är filen orsaken. Sedan kan du göra en binärsökning: behåll hälften av raderna och kontrollera.
2. **Hooks.** Öppna `.claude/settings.json` och ange tillfälligt `[]` i avsnittet `hooks`. Starta om `claude`. Fungerar det? Då ligger problemet i en av hookarna. Aktivera dem en i taget.
3. **MCP-servrar.** Ange på samma sätt tillfälligt ett tomt objekt i avsnittet `mcpServers` i `~/.claude.json` eller `.claude/settings.json`, starta sedan om och kontrollera.
4. **Skills.** Flytta `.claude/skills/` till en tillfällig mapp. Starta och kontrollera.
Vad innebär ”tillfälligt namnbyte”? Filer raderas inte under felsökningen. `mv` eller `git stash` gör att du kan återställa allt med ett enda kommando om det visar sig att det lagret inte var boven.
## Hur byter du arbetsmapp med `/cd` utan att förlora kontexten?
Det viktigaste
Kommandot `/cd ` i Claude Code 2.1.169+ byter arbetsmapp under den aktiva sessionen utan att rensa promptcachen. Det är användbart när den aktuella projektkonfigurationen är trasig: du kan gå till en ren mapp, kontrollera att Claude fungerar och återvända. Tidigare var du tvungen att avsluta sessionen och starta om.
Från ändringsloggen för v2.1.169 den 8 juni:
Lade till kommandot /cd för att byta sessionen till en ny arbetsmapp utan att nollställa promptcachen mitt under sessionen.
— Anthropic Claude Code – ändringslogg, https://code.claude.com/docs/en/changelog
Varför är det användbart vid felsökning? Anta att du befinner dig i projektmappen `~/work/myapp` och Claude Code beter sig konstigt. Tidigare var det enda sättet att kontrollera ”fungerar det över huvud taget?” att avsluta sessionen, gå till en annan mapp och starta igen. Du förlorade kontexten, historiken och den uppvärmda promptcachen. Nu kan du göra så här:
```bash
# In the same session:
/cd ~/sandbox/test
```
Claude byter till den nya mappen och läser dess `CLAUDE.md` (om den finns) som ett meddelande, inte som en ersättning för systemprompten – det innebär att cachen bevaras. Om allt fungerar i `~/sandbox/test` är det tydligt att problemet låg i konfigurationen för `~/work/myapp`.
Den 12 juni rättade v2.1.176 en besvärlig regression – `/cd` visade den gamla git-grenen tills programmet startades om helt. Om din version är äldre uppdaterar du eller ignorerar helt enkelt `git status` under de första meddelandena efter bytet – det hinner komma i kapp.
## Hur konfigurerar du reservmodeller för ett 529-fel?
Det viktigaste
I v2.1.166 lade Anthropic till `fallbackModel` – en kedja med upp till 3 modeller som testas i följd när den primära modellen är överbelastad eller otillgänglig. Kedjan aktiveras endast vid överbelastning och icke-återförsökbara serverfel. Fel som gäller auktorisering, fakturering, hastighetsbegränsningar och transport aktiverar inte reservkedjan – de följer den vanliga logiken för återförsök.
I det beskrivna scenariot körs en lång uppgift i Opus i ett projekt en gång i veckan. Efter 10 minuter returnerar API:t 529 Overloaded och sessionen kraschar. Tidigare var du tvungen att antingen vänta eller byta manuellt till Sonnet med `--model sonnet` och förlora all uppvärmd kontext. I en stor `business/`-mapp med en second-brain-konfiguration tar det ungefär tjugo minuters arbete. Nu finns det en riktig mekanism.
Det exakta citatet från den officiella dokumentationen:
När den primära modellen är överbelastad, otillgänglig eller returnerar ett annat icke-återförsökbart serverfel kan Claude Code växla till en reservmodell i stället för att misslyckas med begäran. Fel som gäller auktorisering, fakturering, hastighetsbegränsning, begärans storlek och transport utlöser aldrig växling – de följer den vanliga hanteringen av återförsök och fel.
— Anthropic-dokumentation – modellkonfiguration, https://code.claude.com/docs/en/model-config
Och separat: så fungerar kedjan:
Konfigurera en eller flera reservmodeller, så provar Claude Code dem i ordning och visar en avisering när den växlar. Bytet gäller endast den aktuella omgången – nästa meddelande försöker återigen med den primära modellen. Kedjorna begränsas till tre modeller efter deduplicering; ytterligare poster ignoreras.
— Anthropic-dokumentation – modellkonfiguration, https://code.claude.com/docs/en/model-config
Det finns två sätt att konfigurera detta. Via CLI:
```bash
claude --fallback-model sonnet,haiku
```
Via `~/.claude/settings.json`:
```json
{
"fallbackModel": ["claude-sonnet-4-6", "claude-haiku-4-5"]
}
```
En separat detalj gäller hastighetsbegränsningar. Anthropic skickar avsiktligt inte ett 429-fel vidare genom kedjan, så att du inte kan kringgå begäransgränsen genom att växla till nästa modell. Reservmodellen används endast när den primära modellen är överbelastad, otillgänglig eller returnerar ett icke-återförsökbart serverfel (till exempel 529 Overloaded). Hastighetsbegränsningar följer den vanliga logiken för återförsök och väntetid.
Ytterligare en detalj: den 12 juni rättade v2.1.174 en regression där komprimering inte hade följt `--fallback-model`. Om du har en lång session som komprimeras när tjänsten är överbelastad anropades reservmodellen inte före den här rättningen. Om du arbetar med långa sessioner (`/compact`, `/loop` över natten) bör du uppdatera till minst v2.1.174.
## Vad ska du åtgärda när `CLAUDE.md`, en hook, MCP eller en skill är boven?
Det viktigaste
När säkert läge har pekat ut det felande lagret varierar lösningen beroende på lager. För `CLAUDE.md` använder du binärsökning eller återgår till en färdig mall på under 200 rader. För en hook kontrollerar du slutkoden (2 blockerar, 1 gör det inte) och logiken. För MCP tar du bort en server och kontrollerar. För en skill kontrollerar du om `SKILL.md` motsäger `CLAUDE.md`.
Här är konkreta strategier för varje lager.
### Om `CLAUDE.md` är boven
Öppna filen och kontrollera storleken. Utifrån den beskrivna erfarenheten bör du **hålla den aktiva `CLAUDE.md` på högst 200 rader** och flytta resten till routrar och stödjande dokument bredvid projektet (hela strukturen för second brain finns i [guiden om second brain](https://ailoot.ai/blog/sv/claude-code-second-brain/)). Om du har 400+ rader är filen nästan säkert boven. Steg:
1. Gör en säkerhetskopia: `cp CLAUDE.md CLAUDE.md.full`.
2. Återgå till en kort fungerande mall. En färdig mall finns i [guiden ”Så konfigurerar du CLAUDE.md”](https://ailoot.ai/blog/sv/claude-md-template/).
3. Starta om Claude Code. Kontrollera.
4. Om det fungerar återställer du regler i små block om 10–20 rader och kontrollerar efter varje block.
5. Hitta blocket som försämrar beteendet. Skriv om det till en hook med rätt slutkod (slutkoder för hooks behandlas i nästa underavsnitt av den här H2-rubriken).
### Om en hook är boven
Den viktigaste frågan är om slutkoden är korrekt. Claude Code-hooks använder:
- **Slutkod 0** – allt är bra; åtgärden fortsätter.
- **Slutkod 1** – ett fel, men **inte blockerande**. Claude fortsätter som om ingenting hade hänt.
- **Slutkod 2** – ett **blockerande** fel. Endast den stoppar faktiskt åtgärden.
Om du skrev `sys.exit(1)` eller `exit 1` i en shell-hook i tron att du blockerade, fungerar den koden som en varningslogg i Claude Code utan att stoppa åtgärden. Ändra den till `2`. Mer information om hooks och hur du konfigurerar dem utan den här fallgropen finns i [den separata guiden](https://ailoot.ai/blog/sv/claude-code-hooks/).
Ett annat vanligt fall är att en hook returnerar ogiltig JSON till stdout. Claude Code tolkar hookens svar som JSON, och om det finns ovidkommande innehåll (en logg, en förloppsmarkör, en emoji) betraktas hooken som misslyckad och åtgärden fortsätter. Regeln är: **stdout innehåller endast JSON; allt annat går till stderr**.
Det tredje fallet är en hook som läser något från `~/.claude/` som säkert läge har dolt. Det är ett normalt scenario. Lösningen är inte att ändra hooken, utan att kontrollera `os.environ.get('CLAUDE_CODE_SAFE_MODE')` i början och avsluta med 0.
### Om en MCP-server är boven
Symtom: MCP-kommandon är tillgängliga men returnerar `failed` utan en tydlig stacktrace. Steg:
1. Kör `claude mcp list` – vilka servrar är definierade?
2. Inaktivera servrar en i taget i `~/.claude.json`: byt namn på nyckeln `claude-server-A` till `_claude-server-A` (det inaktiverar den utan att radera den).
3. Starta om `claude`. Kontrollera vilka anrop som fungerar.
4. När du har hittat den skyldiga servern kontrollerar du dess logg: `claude mcp logs `.
5. Om det är en tredjepartsserver (`@modelcontextprotocol/server-postgres` och liknande) kontrollerar du om den har en ny version. MCP-ekosystemet är fortfarande turbulent; servrar går regelbundet sönder i samband med uppdateringar av Claude Code.
Om du stöter på ”kraschar vid start, och bara med två MCP-servrar” jämför du beteendet i säkert läge utan MCP.
### Om en skill är boven
En skill består av `SKILL.md` plus kod i `.claude/skills//`. Symtom: Claude ignorerar skillen, tillämpar den vid fel tillfälle eller tillämpar den men producerar skräp. Steg:
1. Öppna `SKILL.md`. Kontrollera beskrivningen – den **bör vara 1–2 meningar och tydligt beskriva när den ska användas**. Om det står ”en universell hjälpreda för allt” förstår Claude inte när den ska anropas.
2. Kontrollera om den motsäger `CLAUDE.md`. Om `CLAUDE.md` säger ”skriv alltid tester” men skillens beskrivning säger ”använd för snabb prototypning utan tester” finns det en konflikt.
3. Om skillen använder externa kommandon (npm, python, git) kontrollerar du att de är tillgängliga i systemets PATH. En skill har en egen minimal miljö.
## Vad gör du om säkert läge inte hjälpte: diagnostisera och bevara tillstånd före reparation
Det viktigaste
Om säkert läge också misslyckas finns installation, autentisering, nätverk och infrastruktur kvar som möjliga orsaker. Kör `claude doctor` och granska beläggen. En oklar rapport motiverar inte radering av inställningar eller sessioner: bevara och verifiera först hela tillståndet och reparera sedan bara diagnostiserad installation.
Radering av användartillstånd är ingen genväg för diagnostik. Identifiera felet med kontrollerna nedan; om de inte ger svar bevarar du underlaget och fortsätter undersöka. Varje installationsreparation börjar med verifierad säkerhetskopia och behåller befintligt konto och autentiseringslagringens identitet. Ordning:
1. **`claude doctor`** – automatisk diagnostik. Anthropic skriver i sin dokumentation:
Om claude --version fungerar men något annat går fel kör du claude doctor för att skapa en automatisk diagnosrapport.
— Anthropic-dokumentation – felsökning av installationen, https://code.claude.com/docs/en/troubleshoot-install
2. **Kontrollera om det finns motstridiga installationer.** Många har både en global npm-version och det inbyggda installationsprogrammet installerade samtidigt:
Flera Claude Code-installationer kan leda till versionsskillnader eller oväntat beteende.
— Anthropic-dokumentation – felsökning av installationen, https://code.claude.com/docs/en/troubleshoot-install
3. **Kontrollera om `ANTHROPIC_API_KEY` tar över din OAuth-session.** Det här är en vanlig orsak till att ”ingenting fungerar, nyckeln har gått ut”:
När `ANTHROPIC_API_KEY` är inställd och du har bekräftat den använder Claude Code den nyckeln i stället för dina OAuth-inloggningsuppgifter för prenumerationen.
— Anthropic-dokumentation – felsökning av installationen, https://code.claude.com/docs/en/troubleshoot-install
Lösning: kör `unset ANTHROPIC_API_KEY` i den aktuella shell-sessionen eller ta bort variabeln från `~/.zshrc` / `~/.bashrc`.
4. **Reparera bara installationen som diagnostiken identifierar; bevara allt användartillstånd först.** Ett fel i säkert läge eller en oklar doctor-rapport fastställer inte att användardata måste tas bort. Stoppa alla Claude-sessioner och andra skrivande processer före en konsekvent säkerhetskopia. Behåll samma Unix-konto, HOME, operativsystemets säkra autentiseringslagring och Anthropic-konto; rotera inte nycklar och skapa ingen ersättningsidentitet.
Säkerhetskopieexemplet gäller **Linux med GNU tar**. Använd på macOS eller Windows ett verktyg som bevarar plattformens ACL:er, utökade attribut, länkar och metadata, och verifiera återställning före fortsatt arbete; anta inte att GNU-specifika flaggor fungerar där. Arkivet innehåller autentiseringsuppgifter och sessionstranskript: håll det privat och utanför kodförråd.
```bash
# Run as the same user who owns the Claude state, after stopping writers.
set -eu
umask 077
backup_dir=$(mktemp -d "$HOME/.claude-recovery-XXXXXXXX")
set --
if [ -e "$HOME/.claude" ] || [ -L "$HOME/.claude" ]; then
set -- "$@" .claude
fi
if [ -e "$HOME/.claude.json" ] || [ -L "$HOME/.claude.json" ]; then
set -- "$@" .claude.json
fi
[ "$#" -gt 0 ] || exit 1
tar --acls --xattrs --numeric-owner -cpf "$backup_dir/claude-state.tar" -C "$HOME" "$@"
tar --acls --xattrs --compare -f "$backup_dir/claude-state.tar" -C "$HOME"
sha256sum "$backup_dir/claude-state.tar" > "$backup_dir/claude-state.sha256"
(cd "$backup_dir" && sha256sum -c claude-state.sha256)
mkdir "$backup_dir/restore-check"
tar --acls --xattrs -xpf "$backup_dir/claude-state.tar" -C "$backup_dir/restore-check"
tar --acls --xattrs --compare -f "$backup_dir/claude-state.tar" -C "$backup_dir/restore-check"
printf 'Verified recovery directory: %s\n' "$backup_dir"
```
Alla kommandon måste lyckas. Arkivet täcker hela befintliga `.claude`-trädet, inklusive ignorerade/ospårade sessioner och pluginläge samt `.claude.json`, inte bara git-spårade inställningar. Om någon sökväg är en symbolisk länk eller data finns på en separat konfigurerad plats stannar du och inkluderar det upplösta målet i samma verifierade säkerhetskopia; att arkivera länken ensam kopierar inte målet. Arkivet innehåller inte macOS Keychain eller annan extern autentiseringslagring, så behåll de identiteterna på plats.
Om diagnostiken särskilt identifierar **den äldre lokala installationen** som den konkurrerande kopian flyttar du bara den installationen till den privata återställningskatalogen i stället för att radera konfiguration och sessioner:
```bash
# Use the verified backup_dir from the previous block.
if [ -d "$HOME/.claude/local" ]; then
mv "$HOME/.claude/local" "$backup_dir/legacy-local"
fi
```
Avinstallera npm-installationen bara om diagnostiken identifierar den som konflikt och du avser behålla den fristående installationen. Använd sedan [dokumenterat fristående installationsprogram](https://code.claude.com/docs/en/setup) utan att radera `.claude` eller `.claude.json`:
```bash
curl -fsSL https://claude.ai/install.sh | bash
claude --version
claude doctor
```
På Windows är det fristående installationskommandot fortfarande:
```powershell
irm https://claude.ai/install.ps1 | iex
```
**Återställ separat.** Stoppa skrivande processer igen. Kontrollera arkivets kontrollsumma och extrahera till en tom återställningskatalog enligt ovan; jämför framgångsrikt före användning. Om flyttad äldre installation ska återställas bekräftar du först att `$HOME/.claude/local` inte finns och flyttar sedan `$backup_dir/legacy-local` tillbaka till exakt den sökvägen. Återställ en diagnostiserad inställningsfil från verifierad extraktion först efter att aktuell ersättare bevarats; skriv inte blint över hela trädet. Sessioner, MCP-inställningar och ursprunglig identitet bevaras. En git-ögonblicksbild ensam täcker inte ignorerade/ospårade transkript, autentiseringsuppgifter eller filsystemsmetadata.
## Vad bör du INTE göra när Claude Code är trasigt?
Det viktigaste
Sex felaktiga vanor som hittats i de beskrivna supportfallen: att ändra nycklar före felsökning, göra en fullständig återställning som första steg, få panik över ett UI-fel i en hook, höja en hooks slutkod innan logiken rättats, redigera `CLAUDE.md` utan en skyddsåtgärd för säkert läge och tro att ”Claude lagar sin egen MCP”. Var och en kostar timmar, och inget av detta behövs.
### Ändra inte nycklar före felsökning
”Auktoriseringen fungerar inte” beror i 90% av fallen antingen på att `ANTHROPIC_API_KEY` tar över prenumerationen, ett UI-fel i en hook eller en MCP som har misslyckats. Att byta nycklar löser inget av detta, men orsakar ytterligare en timmes avbrott: du måste återkalla den gamla nyckeln, utfärda en ny, signera om CI med den och uppdatera variablerna i produktion. Kör `claude --safe-mode` först. Fungerar det? Då ligger problemet i anpassningarna; du behöver inte röra nycklarna.
### Gör inte en fullständig återställning innan du har provat säkert läge
Säkert läge ger dig en isolerad miljö på 1 sekund. Radering av `.claude` kan förstöra sessioner, MCP-konfiguration och annat ospårat tillstånd. Diagnostisera först, verifiera en privat säkerhetskopia och använd reversibel flytt bara för installations- eller konfigurationslagret som faktiskt pekats ut.
### Få inte panik över ett UI-fel i en hook
Innan du åtgärdar något kontrollerar du om hooken faktiskt kördes (genom en logg till `stderr` eller en uttrycklig utskrift) i stället för att lita på den visuella indikatorn.
### Höj inte en hooks slutkod innan du har rättat logiken
När din blockerande hook inte blockerar är det frestande att ange `exit 2` och kalla saken klar. Det är en fungerande korrigering, men den döljer ett annat problem: om blockeringen inte fungerade på en månad så gick allt som hooken skulle förbjuda igenom. Gå först igenom git-loggen och ta reda på exakt vad som slank igenom. Lägg sedan till blockeringen. Annars kan en stängd blockering inte göra det ogjort som redan har hänt.
### Redigera inte produktionsfilen `CLAUDE.md` utan skyddsåtgärd för säkert läge
I det beskrivna fallet redigerar du `CLAUDE.md`, Claude börjar bete sig konstigt och du kör `git diff` och ser att någon också lade till en MCP-server och en hook i repot samma kväll. Du skyller på din redigering, återställer den och Claude beter sig fortfarande konstigt. Regeln: innan du kör `git revert` provar du `claude --safe-mode`. Om problemet kvarstår i säkert läge hade din redigering ingenting med det att göra; du behöver inte återställa den.
### Tro inte att ”Claude lagar sin egen MCP”
Ett typiskt scenario: du ber Claude att ”lägga till ett visst verktyg på MCP-servern”, Claude skriver om den fungerande konfigurationen, allt går sönder och sedan ägnar Claude flera omgångar åt att felsöka skadan den orsakat – och förbrukar sessionens kvot under tiden. När MCP inte fungerar ska du **hämta konfigurationen manuellt**; lämna det inte åt agenten. En del av dess verktygsarsenal körs också på MCP, och en trasig MCP innebär en trasig diagnostiker.
## Vart går du efter att du har åtgärdat det?
Det viktigaste
När du har återställt Claude Code lägger du till förebyggande åtgärder så att det inte går sönder igen. Minst detta: `disableBypassPermissionsMode: "disable"` i användarinställningarna, hooks som blockerar `.env` och `git push --force` samt en sandlåda för långa autonoma körningar. Förebyggande-guiden är motsvarigheten till den här guiden.
Efter att du har analyserat incidenten ska du inte återgå till arbetet direkt. Lägg först till förebyggande åtgärder så att incidenten inte upprepas. Du kan förlora timmar på en second brain (mappen `business/` med projektstrukturen) och `CLAUDE.md`, och det är svårt att återställa dem manuellt – det är ett starkt skäl. Minsta uppsättning:
1. **`~/.claude/settings.json`** med `permissions.disableBypassPermissionsMode: "disable"` – ett arkitektoniskt förbud mot bypass-läge, så att ett oavsiktligt startat `--dangerously-skip-permissions` helt enkelt inte fungerar.
2. **Hooks för `Read(./env*)`, `Bash(git push --force)`, `Write(./node_modules/**)`** – sådant som måste fångas upp som en regel, inte en önskan.
3. **Sandlådekonfiguration för långa autonoma körningar** (`/loop`, `/schedule`).
4. **`/compact` med dina egna regler** för vad som ska tas bort ur kontexten, så att Claude inte förbrukar sig självt.
Det fullständiga skyddet i fyra lager finns i [guiden ”Så konfigurerar du Claude Code så att det inte förstör projektet över natten”](https://ailoot.ai/blog/sv/claude-code-safe-overnight-setup/). Den ena guiden behandlar förebyggande åtgärder innan du startar `/loop`; den andra handlar om återställning efter att `/loop` redan har förstört något. Ett logiskt par.
### Källor
- [Anthropic Claude Code – ändringslogg](https://code.claude.com/docs/en/changelog) – officiell ändringslogg med beskrivningar av v2.1.166 (`fallbackModel`), v2.1.169 (säkert läge, /cd), v2.1.174 (fix för komprimering), v2.1.176 (fix för git-grenen i /cd).
- [Anthropic-dokumentation – modellkonfiguration](https://code.claude.com/docs/en/model-config) – avsnitten ”Fallback model chains”, ”Check what triggered fallback”, ”Setting your model”.
- [Anthropic-dokumentation – felsökning av installation och inloggning](https://code.claude.com/docs/en/troubleshoot-install) – motstridiga installationer, `claude doctor`, att `ANTHROPIC_API_KEY` tar över.
Praktiskt material: [Ailoot-dokumentation](https://ailoot.ai/docs/).
Mer material och verktyg: [Ailoot](https://ailoot.ai/).
## Frågor om den här guiden: Återställa Claude Code: säkert läge, /cd och reservmodell
### Betyder fel i säkert läge att jag bör radera ~/.claude?
Nej. Installation, autentisering, nätverk och infrastruktur återstår fortfarande att undersöka. En oklar doctor-rapport är inget belägg för att inställningar eller sessioner måste tas bort; reparera bara diagnostiserat lager.
### Vad måste bevaras före installationsreparation?
Stoppa skrivande processer och säkerhetskopiera hela Claude-tillståndet, inklusive sessioner, plugin-/MCP-konfiguration, ignorerade filer och filsystemsmetadata. Verifiera kontrollsumma och extraktion före fortsatt arbete, behåll befintligt konto och autentiseringslagring och återställ bara diagnostiserat lager utan att blint skriva över aktuellt tillstånd.
## Ailoot · Företaget och dess projektportfölj
Ailoot bygger på etablerad driftserfarenhet, en stor kundbas, stabil service och löpande KPI-kontroll.
Företaget och dess projektportfölj: miljontals kunder; månatlig försäljning för miljarder.
Ailoot använder denna driftserfarenhet för API-åtkomst till AI-funktioner i kundernas produkter, agenter, applikationer och automatiseringar.