תיעוד 41

ניהול סשנים

Grok שומר כל שיחה בדיסק באופן אוטומטי. בין אם אתה עובד ב-TUI, במצב headless או דרך agent stdio, ‏Grok מתעד את חילופי הדברים כסשן. אתה יכול לחדש אותו, להחזיר אותו לאחור (rewind) או לדחוס אותו. מסמך זה מתאר כיצד לנהל סשנים.

#מהם סשנים

סשן הוא שיחה מתמשכת עם היסטוריה מלאה. הוא כולל:

את כל בקשות המשתמש (prompts) ותשובות הסוכן
קריאות לכלים (tool calls) והתוצאות שלהן
מצב רשימת המשימות/TODO
נקודות חזרה לאחור (rewind points) לביטול תורות מאוחרים יותר
שימוש בטוקנים וספירת תורות
סשנים של תת-סוכנים (כאשר מופעלים)

סשנים מזוהים באמצעות מזהה סשן ייחודי (UUIDv7 כאשר Grok מייצר אותו, לקוח יכול לספק מזהה משלו באמצעות -s), ונשמרים בדיסק תחת ~/.grok/sessions/. הגדר את GROK_HOME כדי לדרוס את ספריית הבסיס. כאשר משתנה זה אינו מוגדר, Grok משתמש ב-~/.grok.

#מבנה האחסון

Grok שומר כל סשן בספרייה משלו, מקובץ לפי ספריית העבודה. הוא מבצע קידוד URL לספריית העבודה כדי לקבוע את שם הקבוצה. כאשר השם המקודד עולה על 255 בתים, הוא משתמש במקום זאת ב-slug בתוספת hash, ומתעד את הנתיב המקורי בקובץ .cwd בתוך הקבוצה.

~/.grok/sessions/<encoded-cwd>/<session-id>/
  summary.json            
# metadata: summary/title, timestamps, model ID, message counts
  updates.jsonl           
# ACP session update stream (conversation + tool calls)
  chat_history.jsonl      
# raw chat messages sent to the model
  system_prompt.txt       
# the rendered system prompt, as sent to the model
  prompt_context.json     
# the inputs the system prompt was rendered from
  tool_definitions.json   
# function tools sent on the latest model call (no MCP server__tool entries)
  plan.json               
# TODO/task list state
  rewind_points.jsonl     
# rewind points for /rewind undo
  signals.json            
# session signals (token usage, tool/turn counters)
  feedback.jsonl          
# user feedback and ratings
  compaction_checkpoints/ 
# saved state from compaction (manual or auto)
  subagents/              
# per-subagent metadata (meta.json); the child sessions live in the normal sessions tree

הקובץ summary.json הוא רשומת האינדקס. הוא מתעד את תקציר הסשן והכותרת שנוצרה, מזהה המודל, חותמות הזמן של היצירה והעדכון, ספירת ההודעות, והפניה לסשן האב עבור סשנים מפוצלים (forked) או משוחזרים. הוא גם מתעד את תקציר התור האחרון העדכני ביותר וסיכום של הסשן כדי שממשקי הצגת רשימות יוכלו להציג אותם. הקובץ updates.jsonl הוא יומן השיחה המוסמך שמניע את /resume ושחזור סשן. הקובץ tool_definitions.json משמיט רשומות server__tool של MCP, מפני שהמודל מגיע אליהן דרך search_tool ו-use_tool, אשר כן מופיעים ברשימה. סכומי טוקנים ועלויות לפי תור זמינים דרך grok usage.

#כותרות סשן

כותרת הסשן המוצגת בלוח הבקרה (dashboard) וב-/resume נוצרת באופן אוטומטי מתוך השיחה. מסגרת שורת הפקודה (prompt border) מציגה כותרת רק לאחר /rename ידני, לצד הכיתוב Stashed כאשר טיוטה נשמרת בצד. יצירת הכותרת מתחילה מיד לאחר הבקשה הראשונה שלך כך שלסשן תמיד יש כותרת, ולאחר מכן הכותרת נוצרת מחדש מתוך השיחה כולה בשניים מהתורות הראשונים ומוקפאת. הדבר מאפשר לכותרת להתקדם מעבר לבקשה ראשונה מעורפלת ולשקף את מה שהסשן באמת עוסק בו, תוך שמירה על יציבות לאחר מכן כדי שלא תאבד את המעקב אחר הסשנים שלך. פקודת /rename ידנית תמיד מנצחת: ברגע ששינית שם של סשן, יצירה אוטומטית לעולם לא תדרוס אותו. השתמש ב-/rename --auto כדי להחזיר את הכותרת ליצירה אוטומטית.

#התחלה וסיום של סשנים

#סשן חדש

ה-TUI יוצר סשן חדש בכל פעם שאתה מפעיל אותו. כדי להתחיל מחדש במפורש באמצע סשן:

/new

פעולה זו מנקה את ההקשר הנוכחי ומתחילה שיחה חדשה. כינוי נוסף: /clear.

#יציאה

סיים את הסשן וצא מ-Grok:

/quit

כינוי נוסף: /exit. כדי לעזוב את הסשן הנוכחי אך להישאר ב-Grok, השתמש ב-/home כדי לחזור למסך הפתיחה.

#מחיקת הסשן הנוכחי

/delete

מבקש אישור, ולאחר מכן מסיר לצמיתות את היסטוריית הסשן. מחזיר למסך הפתיחה, או ללוח הבקרה אם פתחת את הסשן מתוך לוח הבקרה. מתוך /resume או מרשימת הסשנים במסך הפתיחה, לחץ על d ולאחר מכן על y. ב-Agent Dashboard, לחיצה כפולה על Ctrl+X (או ריחוף מעל [✗]) מוחקת לצמיתות.

#חידוש סשנים

#מתוך ה-TUI

השתמש בפקודה /resume כדי לעיין בסשנים קודמים ולחדש אותם:

/resume

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

הקלדה בבורר מסננת את הרשימה לפי כותרת וגם מחפשת בתוכן השיחה תוך כדי הקלדה. תוצאות תואמות תוכן מופיעות תחת הכותרת "Extended search results". לחץ על Ctrl+/ כדי לחפש מיד ללא ההשהיה הקצרה.

עבור הסשנים הפעילים ברמה העליונה במציג זה (הורה ופיצולים), כדי להחליף, לשנות שם, להציץ, לשגר או לסגור, השתמש ב-Agent Dashboard: ‏/dashboard (כינויים נוספים: /sessions, /agents-dashboard) או Ctrl+\.

#משורת הפקודה

חדש סשן ספציפי לפי מזהה או כותרת:

grok --resume <session-id-or-title>

ערך שאינו מזהה סשן מושווה מול כותרות סשנים עבור הספרייה הנוכחית, תוך התעלמות מאותיות גדולות וקטנות (השוואה פשוטה של אותיות קטנות), דבר שימושי לאחר /rename. אם מספר סשנים חולקים את אותה כותרת, סשן יחיד ששמו שונה ידנית מנצח כפילויות שנוצרו אוטומטית. אחרת, הפקודה נכשלת עם שגיאה ומפרטת את המזהים התואמים. ערכים במבנה של UUID מטופלים תמיד כמזהי סשן, לעולם לא ככותרות. סקריפטים צריכים להעדיף מזהים.

הפעל את grok --resume ללא ערך כדי לחדש את הסשן האחרון עבור הספרייה הנוכחית.

#ממסך הפתיחה

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

#פיצול ושינוי שם של סשנים

#פיצול (Fork)

פצל את הסשן הנוכחי לסוכן עמית (peer agent) שמתחיל מעותק של השיחה:

/fork [--worktree|--no-worktree] [directive]

העבר directive אופציונלי כדי להגדיר את הבקשה הראשונה של הסשן החדש. השתמש ב---worktree או ב---no-worktree כדי לבחור אם הפיצול ירוץ ב-git worktree חדש. השמט את שניהם כדי להישאל בכל פעם. הדגל --at <turn> אינו נתמך בגרסה זו.

#שינוי שם

שנה את כותרת הסשן הנוכחי:

/rename <title>
/rename --auto

כינוי נוסף: /title. הפקודה /rename --auto מנקה כותרת ידנית ומפעילה מחדש יצירת כותרות אוטומטית.

#הפקודה /rewind

הפקודה /rewind (כינוי נוסף: /undo) מחזירה את השיחה לאחור לתור מוקדם יותר, ומשמיטה תורות מאוחרים יותר. שינויים בקבצים שבוצעו לאחר אותו תור נשארים בדיסק כפי שהם.

/rewind
/undo

כאשר אתה מריץ את /rewind או /undo (או לוחץ על Esc Esc בתוך 800 מילי-שניות בזמן חוסר פעילות עם שורת פקודה ריקה והודעות שיחה), Grok:

מציג רשימה של נקודות חזרה לאחור (אחת עבור כל בקשת משתמש)
מאפשר לך לבחור לאיזו נקודה לחזור לאחור
קוטע את היסטוריית השיחה עד לאותה נקודה

כאשר ההגדרה Confirm before rewind מופעלת (ברירת מחדל ב-/settings), כל בחירה מבקשת אישור (Yes / Yes, and don't ask again / No). האפשרות Yes, and don't ask again מכבה הגדרה זו. כאשר ההגדרה כבויה, הבחירות מבוצעות מיד.

חשוב: /rewind אינו משחזר קבצים בדיסק. רק היסטוריית השיחה נקטעת.

#הפקודה /compact

הפקודה /compact דוחסת את היסטוריית השיחה כדי לחסוך מקום בחלון ההקשר. השתמש בה בסשנים ארוכים שבהם הודעות מוקדמות כבר אינן רלוונטיות.

/compact
/compact [context]

הארגומנט האופציונלי context מאפשר לך לספק הוראות נוספות לגבי מה לשמר במהלך הדחיסה.

#דחיסה אוטומטית

Grok דוחס את השיחה באופן אוטומטי כאשר חלון ההקשר מתקרב למגבלה שלו. תראה התראה כאשר דחיסה אוטומטית מופעלת. ההגדרה context_window בתצורת המודל שלך שולטת במועד ההגעה לסף זה.

#הפקודה /session-info

הצג פרטים אודות הסשן הנוכחי:

/session-info

פקודה זו מציגה:

כותרת הסשן (כאשר מוגדרת)
גרסת המעטפת (Shell version)
שיטת אימות (OAuth לעומת מפתח API. סשנים עם מפתח API מציעים גם grok login עבור SuperGrok)
מזהה סשן
ספריית עבודה
מודל (עם גיבוב מודל עבור מודלים לכתיבת קוד)
ממשק API אחורי ופרופיל sandbox (כאשר מוגדר)
ניצול חלון ההקשר (טוקנים בשימוש וסך כל הטוקנים, לצד אחוז השימוש)

בלשונית Session info, לחץ על ערך כדי להעתיק אותו, או גרור כדי לבחור טווח (אותה הדגשה כמו במציג הכלים). המקש c מעתיק את מזהה הסשן והמקש y מעתיק את כל הבלוק. ההעתקה משתמשת באותו נתיב לוח גזירים כמו שאר חלקי Grok, כולל grok wrap.

#ניהול סשנים במצב Headless

במצב headless, אתה מנהל סשנים באמצעות דגלים של שורת הפקודה:

# New session each time (default)
grok -p "Hello"

# Resume an existing session by ID or title (errors if it does not exist)
grok -p "Continue where we left off" -r <session-id-or-title>

# Continue the most recent session in the current directory
grok -p "What were we doing?" -c

במצב headless, חדש סשן קיים באמצעות -r/--resume, אשר נכשל עם שגיאה אם הסשן אינו קיים, או המשך את הסשן האחרון בספרייה הנוכחית באמצעות -c/--continue. ערך שאינו מזהה מושווה מול כותרות סשנים עבור הספרייה הנוכחית, תוך התעלמות מאותיות גדולות וקטנות (התאמה יחידה ששמה שונה ידנית מנצחת מבין כפילויות. כפילויות שנותרו נכשלות עם שגיאה המציגה את המזהים שלהן. ערכים במבנה של UUID תמיד מטופלים כמזהים). סקריפטים צריכים להעביר ל--r את מזהה הסשן מתוך פלט ה-JSON (ראה להלן).

השתמש ב--s/--session-id רק כדי ליצור סשן חדש עם UUID (נכשל עם שגיאה אם הערך אינו UUID, או אם מזהה זה כבר קיים עבור סשן תחת ספריית הסשנים של היעד). הוא אינו מחדש סשן קיים: זו הייתה התנהגות ה-upsert הנסתרת הישנה. השתמש ב--r/-c במקום זאת. שלב את -s עם -r/-c רק כאשר אתה מעביר גם את --fork-session (מפצל את ההיסטוריה לתוך מזהה חדש. דגל -s אופציונלי קובע את ה-UUID של הצאצא). הדבר תואם למודל מניעת הדריסה של Claude Code (בדיקה מקדימה של הלקוח תחת ספריית העבודה לכתיבה. שימוש סדרתי הוא אמין, שימוש מקבילי עם אותו מזהה פועל על בסיס מיטבי).

כדי לקרוא בחזרה את מזהה הסשן, בקש פלט בפורמט JSON:

grok -p "Hello" --output-format json | jq -r '.sessionId'

#ניהול סשנים באמצעות Agent stdio

בעת בנייה עם ACP, סשנים מנוהלים באמצעות מתודות פרוטוקול:

// Create new session
const { sessionId } = await connection.request("session/new", {
  cwd: "/path/to/project",
  mcpServers: [],
});

// Load existing session
await connection.request("session/load", {
  sessionId: "existing-session-id",
  cwd: "/path/to/project",
  mcpServers: [],
});

// Change a live option (model or reasoning_effort).
// session/new and session/load already return the typed configOptions list.
await connection.request("session/set_config_option", {
  sessionId,
  configId: "model",
  value: { value: "grok-4.6" },
});

הסוכן שומר את כל עדכוני הסשן באופן אוטומטי. לקוחות יכולים להתחבר מחדש ולטעון סשנים קודמים לפי מזהה. ראה Agent mode עבור מזהי האפשרויות, מבנה הערכים, והצצה במצב מוביל (leader-mode snoop).

#פקודת המשנה grok sessions

הצג רשימה או חפש סשנים משורת הפקודה. הפקודה grok sessions דורשת פקודת משנה:

# List recent sessions for the current directory
grok sessions list

# Limit the number of results (default 20)
grok sessions list --limit 50

# Search sessions by keyword (matches titles and prompts)
grok sessions search "rate limit"

הפקודה grok sessions list מציגה סשנים עבור ספריית העבודה הנוכחית, מקובצים לפי תווית worktree. כל שורה מפרטת את מזהה הסשן, תאריכי היצירה והעדכון, מצב המקור ואת התקציר. הפקודה grok sessions search משלבת אינדקס SQLite מקומי עם תוצאות מרוחקות.

#פקודת המשנה grok usage

הדפס נתוני שימוש שמורים בטוקנים ובעלויות עבור סשן. השתמש בזה במקום לקרוא קובצי סשן:

# Session totals plus every recorded turn
grok usage <session-id>

# One turn
grok usage <session-id> 3

הפלט הוא JSON עם sessionId, updatedAt, session ו-turns. תור ספציפי משתמש באותה מעטפת עם איבר יחיד בתוך turns. סכומי הסשן הכוללים מכסים את השיחה כולה, כולל היסטוריה שעברה בירושה על ידי חידוש או פיצול. הערך costUsdTicks הוא 10¹⁰ טיקים לכל דולר ארה"ב (חלק ב-1e10 עבור דולרים). מספר תור חסר מהווה שגיאה. יתרת זכות וחיוב אינטראקטיביים נשארים ב-/usage בתוך ה-TUI.

#סשנים ב-Worktree

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

סשנים ב-worktree מנוהלים פנימית באמצעות מתודות ההרחבה של x.ai/git/worktree/*. פעולות עיקריות:

Create: יצירת worktree חדש עבור סשן מבודד
Apply: מיזוג שינויי ה-worktree בחזרה אל ספריית העבודה הראשית
Remove: ניקוי worktree כאשר הסשן מסתיים

חדש סשן ב-worktree חדש באמצעות grok -w -r <session-id>.

#בדיקת השימוש בדיסק

הפקודה grok du (כינוי נוסף: grok disk-usage) מדווחת מה צורכת תיקיית הבית של grok (~/.grok) בדיסק. היא מפרטת כל ספרייה ברמה העליונה, מהגדולה ביותר לקטנה ביותר, ולאחר מכן כל worktree עם הגודל, הסוג, הגיל, התווית והנתיב שלו. עצי worktree שאינם במעקב הרישום (registry) מופיעים כ-untracked. העבר --json כדי לקבל את אותו דוח כפלט קריא למכונה.

Disk usage for ~/.grok
    412.3 GB  worktrees
      1.2 GB  sessions
    412.0 MB  (top-level files)
    413.9 GB  total
  Worktree clones share storage with their source, so the total can exceed real disk use.

Worktrees
        SIZE  TYPE                AGE        LABEL  PATH
    380.0 GB  session             12d ago    my-fix ~/.grok/worktrees/xai/worktree-abc
     32.3 GB  untracked (session) 40d ago           ~/.grok/worktrees/xai/worktree-old

To reclaim space, run `grok worktree gc --max-age 7d --dry-run`, then the same command without `--dry-run`. Without `--max-age`, gc expires nothing, and it keeps a worktree whose work it cannot find elsewhere, naming each one.
Untracked rows are not in the registry, so gc never visits them. Remove one with `grok worktree rm --dry-run <path>`, then without `--dry-run`.

הערך AGE הוא הערך שהפקודה grok worktree gc מודדת: הזמן שחלף מאז הגישה האחרונה ל-worktree, או מאז יצירתו כאשר מועד זה מאוחר יותר. פעילות של סשן ושל סוכן מעדכנת אותו. מעטפת (shell) או עורך שנשארו פתוחים בספרייה אינם מעדכנים אותו. ל-worktree שאינו במעקב (untracked) אין רשומה ברישום, ולכן גילו נקבע לפי הקובץ החדש ביותר תחתיו.

הגדלים מחושבים לפי ספירת בלוקים פיזיים ב-Unix וגודלי קבצים לוגיים במערכות אחרות, בהתאמה למה שמדווח grok worktree show. שכפול של worktree חולק אחסון עם המקור שלו וכל עותק נספר במלואו, ולכן הסכום הכולל יכול לעלות הן על du -sh והן על השטח שנמצא בפועל בשימוש. כאשר הסכום הכולל עולה על השטח המשומש בכונן, הדוח מציין זאת. הדגל --json כולל את אותם נתונים כ-volume_capacity_bytes ו-volume_available_bytes.

הדוח מודד מערכת קבצים בודדת, זו שמחזיקה את תיקיית הבית של grok. ספרייה בכל מערכת קבצים אחרת נשארת מחוץ לסכום הכולל ונספרת ב-other_filesystem_dirs, ושורות ה-worktree שלה מציגות - עבור הגודל (null ב---json). קישור סמלי (symlink) ברמה העליונה לספרייה, כגון תיקיית worktrees שהועברה למיקום אחר, נספר ב-unfollowed_dir_symlinks. היעד שלו נשאר מחוץ לסכום הכולל, אף על פי שהשורות שתחתיו עדיין נמדדות. ספריות ורשומות שהדוח לא הצליח לקרוא נספרות ב-unreadable_dirs ו-unstatable_entries. הפעל את RUST_LOG=debug grok du כדי לקבל את השמות של כל אחד מהם.

כל שורת worktree ב---json כוללת גם את created_at, last_accessed_at ו-last_modified_at בשניות unix, בתוספת repo_name ו-git_ref. שדות הרישום הם null עבור שורות שאינן במעקב. הערך git_ref הוא הענף שתועד כאשר ה-worktree נרשם, ולא הענף שמופעל (checked out) כעת.

כאשר הרישום אינו זמין, כל שורה מופיעה כ-untracked והדוח מציין את הסיבה. השדה registry ב---json נושא את אותו ערך: read, absent, busy, unopenable או corrupt. רישום במצב busy מוחזק על ידי תהליך אחר, לכן נסה שוב. רישום במצב unopenable סובל מבעיית הרשאות או קלט/פלט, לכן בדוק את הקובץ. רישום במצב corrupt הוא המקרה היחיד שמחייב מחיקה: הסר את הקובץ שהדוח מציין, ולאחר מכן הפעל את grok worktree db rebuild.

כדי לפנות מקום, הפעל את grok worktree gc --max-age 7d, אשר מסיר עצי worktree במעקב שישנים יותר מהגיל שתציין. ללא --max-age, ה-gc אינו מוחק דבר, והוא פונה רק לעצי worktree שהרישום עוקב אחריהם. הסר worktree שאינו במעקב באמצעות grok worktree rm <path>. שתי הפקודות מקבלות את --dry-run ומדווחות מה הן היו עושות: gc סופר את עצי ה-worktree שהוא יסיר, ו-rm מציין את הנתיב.

כל ריצה מעריכה כמה שיותר עצי worktree שהיא מסוגלת בכדקה אחת, מכיוון שאותו מעבר רץ לפי טיימר לצד הסשן שלך, וקריאת עץ עבודה שלם אינה חינמית. כל דבר שהוא לא הגיע אליו נספר כ-Not judged this pass וממתין לריצה הבאה. לכן, במכונה עם מקום רב לפינוי, הפעל את gc שוב עד שמספר זה יגיע לאפס.

לפני הסרת worktree שפג תוקפו, gc בודק האם ההסרה תשמיד עבודה: קבצים שלא בוצע להם commit, קבצים שאינם במעקב (untracked) או קבצים שמתעלמים מהם (ignored), קומיט שאף ref ששרד אינו מחזיק בו, או מצב שנשמר רק בספריית ה-git של אותו worktree. עץ worktree שהוא אינו יכול לבדוק נשמר גם כן. הדוח מונה את עצי ה-worktree שנשמרו ומציין את הסיבה, בנפרד מאלו שתהליך פעיל עיכב. הדגל --force אינו מדלג על הבדיקה, והפקודה grok worktree rm אינה מחילה אותה: היא מסירה את הנתיב שאתה מציין.

קבצים שמתעלמים מהם (ignored) נחשבים כעבודה, למעט חריג אחד: ספרייה שחוקי ההתעלמות של המאגר עצמו מחריגים, ואשר נושאת תג מטמון (cache tag) של כלי מסוים או ששמה תואם לאחת מספריות הפלט שלו (target, node_modules, .venv והשאר). שם בלבד אינו מספיק לעולם, ולכן ספריית build/ שנכתבה ידנית ואיש לא החריג אותה עדיין תגרום לשמירת ה-worktree.

קומיט שרק ה-reflog של ה-worktree עצמו מציין, שזה מה ש-reset --hard או amend משאירים מאחור, מקבל שם קבוע תחת refs/grok/reclaimed/<worktree>/<commit> במאגר שממנו הגיע ה-worktree. מערכת Git מחשיבה reflog כנגישות (reachability) כאשר היא מבצעת prune, ולכן ללא שם זה, הסרת ה-worktree היא זו שהייתה גורמת לקומיט להפוך לבלתי נגיש. שחזר קומיט כזה באמצעות git log refs/grok/reclaimed/ ו-git branch <name> <commit>.

שמות אלה אינם מצטברים. כל מעבר של gc משמיט את אלה שכבר אינם מחזיקים דבר: הקומיט נגיש כעת מ-ref אמיתי, או שגילו מעל 30 יום. הדוח מונה אותם כ-names_collected.

#פרטי אחסון הסשן

#פורמט השמירה

Grok שומר את השיחה בפורמט JSON המופרד בשורות חדשות (JSONL). כל שורה ב-updates.jsonl היא אירוע עדכון סשן ACP עצמאי. פורמט זה תומך ב:

כתיבה הדרגתית (הוספה בלבד במהלך סשן)
קריאה יעילה בהזרמה (עבור שחזור סשן)
ניפוי שגיאות קל (כל שורה היא JSON תקין)

קובצי המצב הקטנים יותר, summary.json, plan.json ו-signals.json, הם קובצי JSON רגילים ולא JSONL. הקובץ JSONL הוא מקור האמת עבור תוכן הסשן. בנוסף, grok sessions search מתחזק אינדקס SQLite FTS5 מקומי על כותרות ובקשות הסשן לצורך חיפוש מהיר לפי מילות מפתח.

#מטא-דאטה של הסשן

הקובץ summary.json מתעד, בין שאר השדות:

info: מזהה הסשן וספריית העבודה
session_summary ו-generated_title: תקציר הסשן והכותרת שנוצרה על ידי המודל
title_is_manual: ערך true כאשר הכותרת הוגדרה ידנית באמצעות /rename (כך שיצירה אוטומטית אינה משנה אותה)
created_at ו-updated_at: חותמות זמן של יצירה ועדכון אחרון
num_messages ו-num_chat_messages: ספירת עדכונים וספירת הודעות צ'אט
current_model_id: המודל שנמצא בשימוש
parent_session_id: סשן המקור עבור פיצול או שחזור
agent_name: הגדרת הסוכן שהייתה פעילה בעת השמירה האחרונה של הסשן
last_turn_summary: תקציר קצר במיוחד של התור האחרון
last_recap: תצוגה מקדימה מוגבלת של הסיכום האחרון של הסשן

#שימוש בדיסק

היסטוריית הסשן (updates.jsonl, chat_history.jsonl) מהווה את עיקר השימוש בדיסק בסשנים ארוכים. השתמש ב-/compact כדי לצמצם את גודל ההיסטוריה.

#טיפים

השתמש ב-/new כדי להתחיל מחדש כאשר ההקשר הנוכחי שלך כבר אינו רלוונטי.
השתמש ב-/compact באופן יזום בסשנים ארוכים כדי לשמור על יעילות חלון ההקשר.
השתמש ב-/rewind כדי לבטל טעויות. הפקודה מחזירה את השיחה לתור מוקדם יותר (שינויים בקבצים מתורות שהוסרו נשארים כפי שהם).
במצב headless, לכוד את sessionId מתוך פלט ה-JSON והעבר אותו ל--r כדי לבנות תהליכי אוטומציה מרובי שלבים ששומרים על ההקשר.
בדוק את /session-info כדי לראות כמה מתוך חלון ההקשר שלך נוצל.