AI מחק את מסד הנתונים: תוכנית שחזור בת 7 דקות

מידע מעשי על עבודה עם Ailoot זמין בתיעוד.

מה לעשות בדקה הראשונה: לעצור, לא להיכנס לפאניקה#

כשזה קורה לכם, הדבר הראשון שעליכם לעשות הוא לעצור את הסוכן. אל תנסו לבטל בעצמכם את פעולותיו, אל תגידו לו ״לשחזר הכול״ ואל תריצו הנחיות חדשות. כל פעולה נוספת של הסוכן עלולה לדרוס את בלוקי הדיסק שבהם הנתונים שלכם עדיין עשויים להיות מאוחסנים.

1. עצרו את הכותב ההרסני בפועל

   קטעו מיד את הפקודה המסוכנת באמצעות Ctrl+C; אל תחכו לסיום המחיקה. עצירת הסוכן אינה עוצרת בהכרח פקודות ילדים, משימות מרוחקות או שאילתות מסד נתונים. זהו את הכותב בפועל ועצרו או בטלו את הפעולה; הסלימו סיום אם הוא ממשיך להשמיד נתונים. השאירו בחיים תהליכים לא קשורים עם קבצים פתוחים שעשויים להיות ניתנים לשחזור.

2. אל תפעילו מחדש את המחשב הנייד

   נתונים שנמחקו עשויים להישאר ניתנים לשחזור, אך האחסון, התנהגות מסד הנתונים, discard/TRIM של SSD וכתיבות בהמשך קובעים זאת. צמצמו כתיבות לכרך שנפגע; אל תניחו שהבתים עדיין קיימים.

3. שמרו תהליכים לא קשורים עם קבצים פתוחים

   שמרו תהליכים לא קשורים שמחזיקים קבצים שנמחקו פתוחים, מפני שייתכן שחזור דרך מתארי הקבצים שלהם. הדבר אינו חל על הכותב ההרסני: עצרו אותו קודם. אל תשאירו מחיקה פועלת רק כדי לשמר קובץ פתוח.

4. תעדו ראיות במכשיר נפרד ומאומת

   תעדו זמן מדויק, נתיבים שנפגעו ופלט פקודות גלוי. אם מקליטים או מעתיקים יומנים, שמרו במכשיר נפרד ומאומת ולא בכרך הפגוע. שמרו שם קבצים ששרדו, כולל במעקב, ללא מעקב ומוחרגים, ואת מטא-נתוני Git לפני ניסיון שחזור.

נותרו 6 דקות לשחזור. בואו נתחיל.

דקות 2–3: תעדו בדיוק מה השתבש#

פתחו חלון טרמינל חדש. לא את החלון שבו הסוכן פועל—חלון אחר. הריצו את שלוש הפקודות האלה לפי הסדר.

1. תעדו בדיוק מה השתנה במאגר git:

git status
git log --since="30 minutes ago" --all --oneline

קובץ במעקב שנמחק עשוי עדיין להתקיים באינדקס או ב-commit. שמרו את עץ העבודה הנוכחי, כולל קבצים ללא מעקב ומוחרגים, לפני כל פעולת restore; שחזור באותו מקום יכול לדרוס עריכות ששרדו. בדקו ושחזרו בעותק נפרד.

2. בדקו אילו תהליכים של הסוכן פועלים:

ps aux | grep -i claude
ps aux | grep -i cursor

זהו איזה תהליך עדיין מבצע כתיבות מסוכנות; התאמה בשם בלבד אינה מספיקה. עצרו את הכותב הזה ואמתו שעצר. שמרו תהליכים לא קשורים עם קבצים פתוחים מועילים; אם סיום מסודר נכשל וההרס נמשך, ייתכן שצריך סיום בכפייה.

3. שמרו את יומן ההפעלה של הסוכן:

Claude Code שומר הפעלות JSONL ב־~/.claude/projects/. Cursor שומר אותן ב־~/.cursor/. צרו עותק עכשיו:

cp -r ~/.claude/projects /external/incident-evidence/claude-projects

החליפו את /external/incident-evidence/ בתיקיית ראיות קיימת במכשיר נפרד, מאומת ומחובר. אל תכתבו את הגיבוי לכרך שנפגע ואל תדרסו ראיות קיימות. התיקייה הזאת מכילה את השיחה המילולית עם הסוכן—אילו פקודות הוא הריץ, מה השיב ובאיזה סדר. זהו המקור העיקרי לבדיקת האירוע, ואולי גם לשחזור קבצים שנמחקו מתוך ההקשר שלו (ראו שלב 4).

דקה 4: git reflog—הסיכוי הטוב ביותר שלכם#

git reflog מתעד תנועות הפניות מקומיות כל עוד הרשומות נשמרות. תפוגה וניקוי משתנים ואובייקטים שאינם נגישים יכולים להימחק; זה אינו ארכיון מובטח של כל commit בעבר. הריצו את צעדי השחזור הבאים מתוך עותק מאגר ששומר במכשיר הנפרד.

שלב 1. הציגו את היומן:

git reflog --all

תקבלו רשימה כמו זו:

1a2b3c4 HEAD@{0}: reset: moving to HEAD~3
9z8y7x6 HEAD@{1}: commit: working version of the dashboard
5w4v3u2 HEAD@{2}: commit: added admin panel

חפשו את הנקודה שלפני הנזק שגרם הסוכן. כל רשומה היא ״תמונת מצב״ של מצב המאגר באותו רגע.

שלב 2. שחזרו לעץ עבודה נפרד:

אחרי העתקת המאגר וכל העבודה ששרדה למכשיר נפרד, הריצו מתוך עותק המאגר ששמרתם. החליפו את הערך ב-SHA המדויק של ה-commit שבדקתם ב-reflog ובחרו ענף ויעד שטרם נעשה בהם שימוש:

RECOVERY_COMMIT='replace-with-verified-commit-sha'
git worktree add -b recovery-check ../recovery-check "$RECOVERY_COMMIT"

בדקו את הקבצים ששוחזרו ב-../recovery-check והשוו לקבצים שלא נשמרו ב-commit ושנשמרו בנפרד, לפני העתקה בחזרה. הפקודה פותחת את ה-commit שנבחר בנפרד; היא אינה מאפסת את עץ העבודה שנפגע. עצי עבודה מקושרים חולקים את מאגר אובייקטי Git של המאגר המועתק, ולכן זו סביבת שחזור ולא גיבוי עצמאי. ראו את תיעוד git-worktree הרשמי.

אם גם reflog נוקה (הסוכן הספיק להריץ git gc):

git fsck --lost-found

הפקודה הזאת מוצאת commits ו־blobs ״אבודים״ (אובייקטים של קבצים) שכבר אינם משויכים לענף כלשהו. הם יופיעו ב־.git/lost-found/commit/ וב־.git/lost-found/other/. כדי לשחזר מהם קובץ:

git cat-file -p <SHA1-blob> > recovered-file.ext

מתי git reflog לא עוזר:

• הקובץ היה רק בעץ העבודה, בלי commit או stash → reflog לא יכול למצוא אותו
• עברו יותר מ־90 יום (הערך הסטנדרטי gc.reflogExpire) ו־git gc כבר הופעל
• כל המאגר נמחק (rm -rf .git)—במקרה כזה תצטרכו את Time Machine או תמונת מצב

דקה 5: שחזרו את מסד הנתונים מגיבוי#

מסד הנתונים נמחק באמצעות DROP DATABASE,‏ DROP TABLE או DELETE FROM ... WHERE ... (ללא תנאי WHERE). מה עושים?

שלב 1. בדקו אם הספק שלכם מציע PITR:

שלב 2. שחזרו למופע חדש, לא לישן:

לעולם אל תשחזרו מעל מסד נתונים פעיל. צרו מופע חדש מהגיבוי, ואז העבירו אליו את היישום. אם משהו ישתבש, תוכלו להחזיר את ה־DNS לאחור.

שלב 3. אם PITR לא היה מופעל, השתמשו בתמונת המצב העדכנית ביותר:

# AWS RDS, list snapshots:
aws rds describe-db-snapshots --db-instance-identifier my-db

# Restore from a snapshot:
aws rds restore-db-instance-from-db-snapshot \
  --db-instance-identifier my-db-restored \
  --db-snapshot-identifier rds:my-db-2026-05-28-12-00

הסתייגות לגבי Supabase, שתפסה אנשים רבים ב־2026: כאשר PITR מופעל, הגיבויים היומיים מפסיקים להיווצר. התנהגות לא אינטואיטיבית; אתם עלולים להישאר בלי גיבויים כלל. בדקו בלוח הבקרה → Database → Backups ש־PITR פעיל ושיש לכם גם תמונת מצב לשחזור.

דקה 6: Time Machine,‏ lsof ותמונות מצב של הדיסק#

macOS—Time Machine:

# List snapshots:
tmutil listbackups

# Restore a file from the latest backup:
tmutil restore /Volumes/Backup/.../my-project/file.tsx ~/projects/my-project/file.tsx

Time Machine יוצר תמונות מצב מדי שעה, שומר תמונות שעתיות במשך יום, תמונות יומיות במשך שבוע ותמונות שבועיות ללא הגבלת זמן. אם המחשב הנייד מחובר ל־Time Capsule או לכונן חיצוני, הפרויקט שלכם זמין ברזולוציה של שעה.

Linux—הקובץ נמחק, אבל תהליך עדיין מחזיק אותו פתוח:

# Find all “deleted” files that a process still has open:
sudo lsof | grep deleted

# You'll get lines like:
# node 12345 user 24w REG 8,1 4096 1234567 /path/to/deleted/file.txt (deleted)

# Copy the file directly from /proc/PID/fd/N:
sudo cp /proc/12345/fd/24 ~/recovered-file.txt

סיכויי ההצלחה הם ~95% אם התהליך לא נסגר. עובד עם ext4, xfs, btrfs.

macOS—המקבילה באמצעות lsof:

lsof | grep deleted

קשה יותר להעתיק את הקובץ (אין /proc/), אבל אפשר לעשות זאת עם lldb:

lldb -p 12345
(lldb) memory read --outfile recovered.txt --binary 0xADDRESS 0xSIZE

תמונת מצב של הדיסק כולו (Linux, מוצא אחרון):

sudo dd if=/dev/sda1 of=/external/disk-image.img bs=4M status=progress

כך נשמרת המחיצה כולה כקובץ תמונה. לאחר מכן שחזרו באמצעות extundelete או photorec. סיכויי השחזור תלויים בכמות הנתונים שנכתבו לדיסק מאז המחיקה. אם לא נכתב דבר, הסיכוי הוא 80–90%. אם הדיסק כבר פעל במשך שעה, הסיכוי הוא 20–30%.

דקה 7: מה עושים אם אין גיבוי#

אפשרות 1—תמיכת הספק:

AWS,‏ Yandex Cloud,‏ Google Cloud ו־DigitalOcean משחזרים מדי פעם נתונים מהאחסון הפנימי שלהם, גם אחרי אסון אצל לקוח, ובייחוד בתוכניות בתשלום. פתחו קריאת תמיכה, ציינו את השעה המדויקת של האירוע וצרפו צילומי מסך של המצב. הדבר מצליח לרוב אצל ספקים גדולים ששומרים גיבויים אוטומטיים אצלם. סיכויי ההצלחה הם 40–60%; חלון המענה הוא 24–72 שעות.

אפשרות 2—ניהול גרסאות של S3:

אם הקבצים היו ב־S3 (או ב־Yandex Object Storage) וניהול הגרסאות הופעל, כל הגרסאות קיימות פיזית; הן רק מסומנות כ״נמחקו״.

# AWS—list versions:
aws s3api list-object-versions --bucket my-bucket --prefix files/

# Restore a version:
aws s3api copy-object \
  --bucket my-bucket \
  --copy-source my-bucket/files/data.json?versionId=ABC123 \
  --key files/data.json

הסתייגות קריטית: Claude Code אינו שומר הפעלות לנצח—קובצי JSONL ישנים נמחקים אוטומטית אחרי כמה שבועות. כדי להבטיח שיהיה לכם חודש של היסטוריית JSONL במקרה של אסון, העתיקו את ~/.claude/projects/ לכונן חיצוני פעם בשבוע באמצעות משימת cron פשוטה:

# In crontab, every Sunday at 03:00:
0 3 * * 0 rsync -av ~/.claude/projects/ /external/claude-history-backup/

זה בחינם ויציל אתכם כש״הכול אבד, אין גיבוי וה־reflog ריק״.

7 כללים למניעת הישנות#

1. Plan Mode לפני כל פעולה הרסנית. ב־Claude Code:

claude --plan

הסוכן בונה תוכנית לפני שהוא פועל. אתם קוראים אותה, רואים DROP TABLE users ומבטלים. בלי Plan Mode, הסוכן מחליט בעצמו ומבצע בתוך אלפיות שנייה. מידע נוסף במדריך Plan Mode ב־Claude Code.

2. Hooks כמנגנון התרעה נוסף. השתמשו ב-hook של PreToolUse שנבדק וקורא את אירוע ה-JSON מ-stdin ויוצא עם 2 כשמזוהה פעולה בסיכון גבוה. הדוגמה המלאה בהמשך מכסה Bash, ‏Write ו-Edit; היא אינה גבול אבטחה ויכולה להחמיץ פעולות עקיפות. שמרו הרשאות מסד נתונים ו-sandbox מוגבלים.

3. משתמש מסד נתונים לקריאה בלבד עבור הסוכן. צרו משתמש נפרד לסוכן שאין לו הרשאות DROP,‏ TRUNCATE או DELETE:

CREATE USER claude_readonly WITH PASSWORD 'xxx';
GRANT CONNECT ON DATABASE myapp TO claude_readonly;
GRANT USAGE ON SCHEMA public TO claude_readonly;
GRANT SELECT ON ALL TABLES IN SCHEMA public TO claude_readonly;

כשהסוכן באמת צריך לכתוב, עברו ידנית למשתמש אחר. משתמש לקריאה בלבד מספיק למשימות יומיומיות (ניתוח נתונים, דוחות ולוחות בקרה).

4. שמרו ב־Git שינויים שנבדקו. hook מסוג PostToolUse ב־.claude/settings.json יכול להציג תזכורת אחרי Write ו־Edit:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "printf '%s\\n' 'בדקו את ה־diff ובצעו commit ידני רק לקבצים שסוכמו.' >&2"
          }
        ]
      }
    ]
  }
}

הדוגמה רק מציגה תזכורת; היא לא מוסיפה קבצים לאינדקס ולא יוצרת commit. בדקו את ה־diff ובצעו commit ידני רק לקבצים שסוכמו. ה־reflog לא שומר שינויים שלא נכללו ב־commit.

5. פרויקט sandbox לניסויים. לעולם אל תתנו לסוכן לעבוד בפרויקט שמכיל נתוני לקוחות אמיתיים. צרו תיקייה נפרדת ~/sandbox-projects/, עם עותק של הפרויקט ונתונים סינתטיים. השתמשו בה כדי לנסות הנחיה, סוכן או שרת MCP חדש. אם משהו יתקלקל, לא ייגרם נזק.

6. תמונות מצב של הדיסק באמצעות restic מדי שעה.

# Install:
brew install restic  # macOS
sudo apt install restic  # Linux

# Create repository:
restic init --repo /external/backups

# Back up the current project:
restic --repo /external/backups backup ~/projects

# Schedule cron every hour:
crontab -e
# Add:
0 * * * * restic --repo /external/backups backup ~/projects

שבעה ימים של גיבויים שעתיים, ארבעה שבועות של גיבויים יומיים—ותוכלו תמיד לחזור לכל נקודה בעבר. זה בחינם ודורש 10 דקות בלבד להגדרה.

7. ארכבו הפעלות JSONL של Claude Code. הזכרנו זאת קודם, אבל נחזור על כך ככלל נפרד: תזמנו משימת rsync שבועית של ~/.claude/projects/ לכונן חיצוני. זה בחינם ודורש שורה אחת ב־crontab.

Hooks מוכנים לחסימת פקודות מסוכנות#

מזגו את הרשומה הזאת ל-.claude/settings.json בלי להחליף hooks קיימים:

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash|Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "python3 \"$CLAUDE_PROJECT_DIR/.claude/hooks/check-risk.py\""
          }
        ]
      }
    ]
  }
}

צרו .claude/hooks/check-risk.py עם סקריפט Python 3 הבא:

import json
import re
import sys
from pathlib import Path

try:
    event = json.load(sys.stdin)
    tool = event["tool_name"]
    data = event["tool_input"]
    blocked = False
    if tool == "Bash":
        command = data["command"]
        blocked = bool(re.search(
            r"drop\s+(database|table)|truncate\s+table|"
            r"delete\s+from.*where\s+1|rm\s+-rf|"
            r"git\s+reset\s+--hard|git\s+push.*(--force|-f)|"
            r"chmod\s+-R\s+777",
            command, re.IGNORECASE | re.DOTALL))
    elif tool in ("Write", "Edit"):
        path = Path(data["file_path"]).resolve()
        blocked = (".git" in path.parts or path.name.startswith(
            (".env", "credentials", "secrets")))
except (ValueError, KeyError, TypeError, OSError):
    print("BLOCKED: invalid hook input", file=sys.stderr)
    sys.exit(2)

if blocked:
    print("BLOCKED: high-risk command or sensitive path", file=sys.stderr)
    sys.exit(2)
sys.exit(0)

ה-hook קורא את אירוע ה-JSON המתועד מ-stdin, בודק tool_input.command או tool_input.file_path ויוצא עם 2 בהתאמה. הוא בודק גם Write וגם Edit. בדקו דוגמה לא מזיקה שמותרת ודוגמה חסומה לפני הסתמכות עליו ואמתו ש-Python והסקריפט שהוגדר אכן מתחילים.

זהו מנגנון התראה לקסיקלי: הוא עלול להחמיץ סדר דגלים אחר, סקריפטים, כינויים, פקודות מוסוות, כלים אחרים וכתיבות עקיפות; הוא עלול גם לדחות דוגמאות מצוטטות לא מזיקות. הוא אינו מעניק או מסיר הרשאות מערכת הפעלה או מסד נתונים. השאירו פרטי גישה לייצור מחוץ לסביבת הסוכן, השתמשו בתפקיד מסד נתונים לקריאה בלבד וב-sandbox נאכף והגנו על תצורת ה-hook מפני שינוי. ראו את ההפניה הרשמית לקלט hook ולקודי יציאה.

לפעולה חריגה מכוונת, סקרו אותה והריצו מחוץ לסוכן עם החשבון המוגבל המתאים. משתנה סביבה ב-shell אינו ממשק מתועד להשבתת hook, ו-hooks אינם שולטים בפקודות מסוף רגילות.

מתי לתת ל־AI הרשאות (ומתי לא)#

Anthropic מתעדת את הדגל --dangerously-skip-permissions (המכונה גם מצב YOLO) כאפשרות ל״סביבות מהימנות״. במציאות של 2026, זו דרך ישירה לאסון. כשסוכן לא חייב לבקש אישור, הוא:

• מריץ כל פקודת Bash בלי אישור
• כותב קבצים בלי לשאול
• יכול להפעיל תת־סוכן, שיורש את מצב YOLO בלי אפשרות לבטל אותו

הנקודה השלישית היא הערמומית ביותר. אם תפעילו את הסוכן הראשי עם YOLO, גם תתי־הסוכנים שלו יהיו במצב YOLO ואי אפשר יהיה לעקוף זאת. הנחיה אחת—ומפל של 10 סוכנים מקבילים יכול לעשות כל דבר במערכת שלכם.

כלל:

חלופה—הרשאות מדויקות. ב־.claude/settings.json:

{
  "permissions": {
    "allow": [
      "Bash(git status:*)",
      "Bash(git log:*)",
      "Bash(npm run build:*)",
      "Read(*)",
      "Edit(src/**)"
    ],
    "deny": [
      "Bash(rm:*)",
      "Bash(git push:*)",
      "Edit(.env)",
      "Edit(prisma/migrations/*)"
    ]
  }
}

הסוכן רואה מה מותר ומה אסור. אינכם צריכים ללחוץ על ״כן״ או ״לא״ בכל פעם—הסוכן עובד במהירות ואתם שולטים בגבולות ההרשאות.

בהמשך: רשימת בדיקה בת 7 דקות לסימנייה#

רשימת בדיקה: ״AI מחק את זה—מה עושים?״

1. עצרו מיד את הכותב ההרסני בפועל; אמתו שפעולות ילד או פעולות מרוחקות נעצרו
2. אל תאתחלו; שמרו תהליכים לא קשורים שמחזיקים קבצים שנמחקו פתוחים
3. תעדו זמן אירוע וראיות פקודות במכשיר נפרד ומאומת
4. העתיקו למכשיר הנפרד קבצים ששרדו, מטא-נתוני Git ויומני הפעלות רלוונטיים
5. בעותק המאגר ששמרתם בדקו git reflog --all ושחזרו commit מאומת ל-worktree נפרד
6. אם git לא עזר—git fsck --lost-found
7. מסד נתונים: PITR (AWS/Yandex/Supabase) או תמונת המצב העדכנית ביותר
8. קבצים: Time Machine ב־Mac,‏ lsof ב־Linux
9. מוצא אחרון: תמיכת הספק + ניהול גרסאות של S3
10. אחרי השחזור, הגדירו את 7 כללי המניעה שבמדריך הזה

הבא—הגנה שיטתית:

• Plan Mode ב־Claude Code—כדי שהסוכן יכין תוכנית לפני פעולה הרסנית
• Hooks ב־Claude Code—תבניות מוכנות לחסימת פקודות מסוכנות
• איך לבטל שינויים ב־Claude Code—מדריך מפורט ל־/rewind, ל־git ול־5 שיטות ביטול סטנדרטיות
• בדיקת אבטחה ב־Claude Code—בדיקות אבטחת קוד תקופתיות

עברו אל Ailoot.