@thegitai/cli 1.0.0-preview.3 → 1.0.0-preview.31

package/dist/src/help-text.js

@@ -14,7 +14,7 @@ const PASTE_SHORTCUT = pasteShortcutForPlatform();
 const HELP_MARKDOWN = [
     '# TheGitAI',
     '',
-    'Interactive terminal coding agent. Local repo indexing, file edits, and',
+    'Interactive terminal coding agent. Local repo search, file edits, and',
     'shell commands run on your machine. Model inference and server-executed',
     'tools run on the server.',
     '',
@@ -22,11 +22,16 @@ const HELP_MARKDOWN = [
     '',
     '- `ai` — start an interactive chat session in the current repo',
     '- `ai "<request>"` — start an interactive session with `<request>` as the first message',
+    '- Coding sessions require terminal stdin and stdout; piped prompts are not supported.',
     '',
     '## Auth',
     '',
-    '- `ai login` — sign in to TheGitAI (opens your browser to the website)',
-    '- `ai login --no-browser` — print a URL and paste the code (for SSH/headless)',
+    '- `ai` — signs you in if you are not already, then starts a session',
+    '- `ai login` — the same thing; kept for muscle memory',
+    '- Signing in opens your browser. When it cannot open one — over SSH, in a',
+    '  container, or when the browser you want is on another device — the same',
+    '  screen prints a URL you can open anywhere and takes the code that page',
+    '  gives you back. There is no mode to pick and no flag to remember.',
     '- `ai whoami` — show the signed-in account',
     '- `ai --usage` — show account usage percentage and reset times',
     '- `ai logout` — sign out',
@@ -35,8 +40,8 @@ const HELP_MARKDOWN = [
     '',
     '- `ai --list-sessions` — list saved sessions for this repo',
     '- `ai --session <id|name>` — resume a saved session by id or name',
-    '- Sessions are stored locally and scoped to the current repo. The five',
-    '  most recent sessions per repo are kept.',
+    '- Sessions are stored locally and can be listed or resumed in the same repo.',
+    '  Continuing one requires the TheGitAI account used for that session.',
     '',
     '## Options',
     '',
@@ -46,7 +51,9 @@ const HELP_MARKDOWN = [
     '',
     '## Modes',
     '',
-    '- Default — asks before shell commands and file edits.',
+    '- Default — asks before creating, editing or deleting files and before',
+    '  running commands. Each answer can be remembered for the rest of the',
+    '  session; see Safety & approvals.',
     '- Auto-Accept — approves shell commands and file edits for the session.',
     '- Plan — read-only; the agent can inspect, ask typed questions, and plan,',
     '  with file-reading shell commands only. It will not edit files or run tests,',
@@ -56,7 +63,15 @@ const HELP_MARKDOWN = [
     '## Keys & clipboard',
     '',
     '- **Enter** sends • **Shift+Tab** cycles modes • **Esc** cancels the turn •',
-    '  **Ctrl+C** quits. These are the same on macOS, Linux, and Windows.',
+    '  **Ctrl+C** clears the composer or the queued message, and quits once there',
+    '  is nothing left to clear. These are the same on macOS, Linux, and Windows.',
+    '- **While the agent is working**, Enter queues your message and locks the',
+    '  composer. Press **Enter** again to send it into the running turn: the agent',
+    '  picks it up at its next step instead of waiting for the turn to finish, and',
+    '  the Your messages panel tracks it from queued to delivered. **↑** brings it',
+    '  back for editing and **Esc**/**Ctrl+C** discards it; both unlock the',
+    '  composer for the next message. **Ctrl+V** pastes a screenshot onto the',
+    '  queued message, and it is delivered into the running turn with the text.',
     `- **Paste** into the composer with your terminal's paste shortcut (\`${PASTE_SHORTCUT}\``,
     '  on this system) or by right-clicking the composer.',
     '- **Copy** from the transcript by dragging to select; double-click copies a',
@@ -69,6 +84,8 @@ const HELP_MARKDOWN = [
     '',
     '- `/help` — show this help',
     '- `/about` — show version and platform info',
+    '- `/report` — file a bug: opens the public GitHub issue form in your',
+    '  browser (the tracker is public — do not paste secrets)',
     '- `/usage` — show account usage percentage and reset times',
     '- `/model` — list supported models and pick one',
     '- `/model <id>` — switch the active model without clearing history',
@@ -77,14 +94,34 @@ const HELP_MARKDOWN = [
     '  browse them, press Enter to expand one and read its output, k to stop it',
     '- `/jobs output <id>` — print one job\'s full captured output',
     '- `/jobs kill <id>` — stop one background job',
-    '- `/clear` — clear the current conversation history',
+    '- `/new` — start a new conversation; this session remains saved',
+    '- `/logout` — sign out and quit',
     '- `/exit` — quit the session',
     '',
     '## Safety & approvals',
     '',
-    '- TheGitAI asks before running shell commands or applying file edits.',
-    '- At each prompt: **y** approves once, **a** approves the rest of the',
-    '  session, **n** denies.',
+    '- In Default mode TheGitAI asks before it creates a file, edits an existing',
+    '  file, deletes a file, or runs a command. These are four separate',
+    '  permissions: allowing edits does not allow deletions, and allowing file',
+    '  changes does not allow commands.',
+    '- At each prompt: **↑/↓** moves between choices, **Enter** confirms the',
+    '  highlighted one, and **Esc** denies. Deny is selected by default.',
+    '  Single-letter shortcuts were removed on purpose: a prompt can appear',
+    '  while you are typing, and a stray letter must never approve anything.',
+    '- Every prompt offers Approve once, an "Always allow" for that kind of',
+    '  action, and Deny. A command also offers to remember just its prefix — for',
+    '  example approving `npm test -- --watch=false` can allow `npm test`.',
+    '- A prefix is only offered when the command shows a plain verb, as in',
+    '  `npm test` or `git status`. Commands with no verb (`ls -la`), interpreters',
+    '  and wrappers (`bash -c`, `python -c`, `env`, `timeout`, `make`), and',
+    '  destructive or network binaries (`rm`, `sudo`, `curl`) are never offered',
+    '  one — a bare binary grant would mean "anything this program can do".',
+    '  `npm run` must name its script, so the grant is `npm run build`.',
+    '- A remembered prefix never covers a command that chains, pipes, redirects,',
+    '  or substitutes, so allowing `npm test` can never green-light',
+    '  `npm test && rm -rf build`.',
+    '- Everything you allow lasts for the current session only and is forgotten',
+    '  when it ends. `/new` clears it immediately.',
     '- If an approved `sudo` command needs a password, the TUI shows the exact',
     '  command and keeps the password masked and local.',
     '- `-y` / `--yes` at startup auto-approves every shell command and file',
@@ -97,17 +134,22 @@ const HELP_MARKDOWN = [
     '  ends.',
     '- File and shell operations are confined to the target repo root.',
     '- Sensitive directories (`.git`, `node_modules`, build output) are',
-    '  never indexed.',
+    '  excluded from search and listing.',
     '',
     '## Troubleshooting',
     '',
-    '- "Not logged in" → run `ai login`.',
     '- Auth or permission errors → run `ai whoami` to confirm the signed-in',
     '  account.',
     '- Usage or quota errors → run `ai --usage`.',
-    '- Stuck on the wrong account → `ai logout`, then `ai login` again.',
-    '- For anything else, re-run the command and report the printed error',
-    '  message — there is no client-side debug mode by design.',
+    '- Signed in with the wrong account → `/logout` (or `ai logout`), then run',
+    '  `ai` and sign in as the account you intended to use.',
+    '- The browser did not open, or opened on the wrong machine → open the URL',
+    '  printed on the sign-in screen anywhere you like, choose "On another',
+    '  computer" on that page, and paste the code back into the terminal.',
+    '- A local session was used with a different sign-in → sign in with the',
+    '  account you used for that session or start a new session.',
+    '- For anything else, re-run the command and file the printed error',
+    '  message with `/report` — there is no client-side debug mode by design.',
 ].join('\n');
 export function formatAboutCard() {
     return [
@@ -126,8 +168,15 @@ export function formatInteractiveHelpText() {
     return HELP_MARKDOWN;
 }
 export function formatCliHelpText({ color = false } = {}) {
-    if (!color)
-        return HELP_MARKDOWN;
+    if (!color) {
+        return HELP_MARKDOWN.split('\n')
+            .map((line) => line
+            .replace(/^#{1,6}\s+/, '')
+            .replace(/^-\s+/, '  ')
+            .replace(/`([^`]+)`/g, '$1')
+            .replace(/\*\*([^*]+)\*\*/g, '$1'))
+            .join('\n');
+    }
     return HELP_MARKDOWN.split('\n')
         .map((line) => {
         const heading = line.match(/^(#{1,6})\s+(.*)$/);

package/dist/src/permissions.js

@@ -0,0 +1,243 @@
+import { getUnquotedShellText } from './agent-mode.js';
+export const PERMISSION_BUCKETS = ['create', 'edit', 'delete', 'run'];
+export function createSessionGrants() {
+    return { buckets: [], commandPrefixes: [] };
+}
+export function bucketActionLabel(bucket) {
+    if (bucket === 'create')
+        return 'create files';
+    if (bucket === 'edit')
+        return 'edit files';
+    if (bucket === 'delete')
+        return 'delete files';
+    return 'run commands';
+}
+const NO_PREFIX_GRANT_BINARIES = new Set([
+    'rm',
+    'rmdir',
+    'mv',
+    'dd',
+    'mkfs',
+    'shred',
+    'sudo',
+    'doas',
+    'su',
+    'chmod',
+    'chown',
+    'chgrp',
+    'kill',
+    'pkill',
+    'killall',
+    'shutdown',
+    'reboot',
+    'curl',
+    'wget',
+    'ssh',
+    'scp',
+    'nc',
+    'eval',
+    'exec',
+    'source',
+]);
+const INTERPRETER_OR_WRAPPER_BINARIES = new Set([
+    'bash',
+    'sh',
+    'zsh',
+    'fish',
+    'dash',
+    'ksh',
+    'csh',
+    'tcsh',
+    'python',
+    'python2',
+    'python3',
+    'node',
+    'deno',
+    'bun',
+    'ruby',
+    'perl',
+    'php',
+    'lua',
+    'osascript',
+    'awk',
+    'gawk',
+    'sed',
+    'env',
+    'timeout',
+    'xargs',
+    'nohup',
+    'setsid',
+    'watch',
+    'script',
+    'nice',
+    'ionice',
+    'stdbuf',
+    'time',
+    'sudo',
+    'doas',
+    'su',
+    'find',
+    'make',
+]);
+const SCRIPT_RUNNER_VERBS = new Set(['run', 'exec', 'run-script', 'x', 'dlx']);
+const VERB_PATTERN = /^[A-Za-z][A-Za-z0-9_:-]*$/;
+const BINARY_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._+-]*$/;
+const SHELL_CONTROL_OPERATOR_PATTERN = /[&|;<>\n]/;
+const COMMAND_SUBSTITUTION_PATTERN = /`|\$\(/;
+function normalizeCommand(command) {
+    return String(command ?? '').trim().replace(/\s+/g, ' ');
+}
+function parseCommand(command) {
+    const raw = String(command ?? '');
+    if (!raw.trim())
+        return null;
+    if (COMMAND_SUBSTITUTION_PATTERN.test(raw))
+        return null;
+    if (SHELL_CONTROL_OPERATOR_PATTERN.test(getUnquotedShellText(raw)))
+        return null;
+    const all = normalizeCommand(raw).match(/\S+/g) ?? [];
+    const tokens = [];
+    for (const token of all) {
+        if (!tokens.length && /^[A-Za-z_][A-Za-z0-9_]*=/.test(token))
+            continue;
+        if (!tokens.length && token === 'command')
+            continue;
+        tokens.push(token);
+    }
+    if (!tokens.length)
+        return null;
+    const binary = (tokens[0].split('/').pop() ?? '').trim();
+    if (!binary)
+        return null;
+    tokens[0] = binary;
+    return { canonical: tokens.join(' '), tokens };
+}
+function grantPrefixFromTokens(tokens) {
+    const binary = tokens[0];
+    if (!BINARY_PATTERN.test(binary))
+        return null;
+    if (NO_PREFIX_GRANT_BINARIES.has(binary))
+        return null;
+    if (INTERPRETER_OR_WRAPPER_BINARIES.has(binary))
+        return null;
+    const verb = tokens[1];
+    if (!verb || !VERB_PATTERN.test(verb))
+        return null;
+    if (SCRIPT_RUNNER_VERBS.has(verb)) {
+        const script = tokens[2];
+        if (!script || !VERB_PATTERN.test(script))
+            return null;
+        return `${binary} ${verb} ${script}`;
+    }
+    return `${binary} ${verb}`;
+}
+export function commandGrantPrefix(command) {
+    const parsed = parseCommand(command);
+    return parsed ? grantPrefixFromTokens(parsed.tokens) : null;
+}
+export function isBucketGranted(grants, bucket) {
+    return Boolean(grants?.buckets.includes(bucket));
+}
+export function isCommandGranted(grants, command) {
+    if (!grants)
+        return false;
+    if (grants.buckets.includes('run'))
+        return true;
+    if (!grants.commandPrefixes.length)
+        return false;
+    const parsed = parseCommand(command);
+    if (!parsed)
+        return false;
+    if (grantPrefixFromTokens(parsed.tokens) === null)
+        return false;
+    return grants.commandPrefixes.some((prefix) => parsed.canonical === prefix || parsed.canonical.startsWith(`${prefix} `));
+}
+export function grantBucket(grants, bucket) {
+    if (!grants.buckets.includes(bucket))
+        grants.buckets.push(bucket);
+}
+export function grantCommandPrefix(grants, prefix) {
+    const normalized = normalizeCommand(prefix);
+    if (!normalized)
+        return;
+    if (!grants.commandPrefixes.includes(normalized)) {
+        grants.commandPrefixes.push(normalized);
+    }
+}
+export function buildPermissionOptions(bucket, command) {
+    const options = [
+        { label: 'Approve once', decision: { kind: 'once' } },
+    ];
+    const prefix = bucket === 'run' && command ? commandGrantPrefix(command) : null;
+    if (prefix) {
+        options.push({
+            label: `Always allow: ${prefix}`,
+            decision: { kind: 'always-prefix', prefix },
+        });
+    }
+    options.push({
+        label: `Always allow: ${bucketActionLabel(bucket)}`,
+        decision: { kind: 'always-bucket' },
+    });
+    options.push({ label: 'Deny', decision: { kind: 'deny' } });
+    return options;
+}
+function declinedSubject(bucket) {
+    if (bucket === 'run') {
+        return { noun: 'command', effect: 'Nothing was executed' };
+    }
+    if (bucket === 'create') {
+        return { noun: 'file creation', effect: 'Nothing was created' };
+    }
+    if (bucket === 'delete') {
+        return { noun: 'file deletion', effect: 'Nothing was deleted' };
+    }
+    return { noun: 'edit', effect: 'Nothing was changed' };
+}
+function declinedResponse(bucket, toolName, extra) {
+    const { noun, effect } = declinedSubject(bucket);
+    return {
+        ok: false,
+        skipped: true,
+        ...extra,
+        failureCategory: 'user_declined',
+        failureDetails: {
+            category: 'user_declined',
+            tool: toolName,
+            action: 'Respect the real user’s decision. Do not retry the same or an equivalent action; reconsider the approach or ask one specific question if needed.',
+        },
+        error: `The real user rejected this proposed ${noun}. ${effect}; this was not a tool failure or an automated system skip.`,
+    };
+}
+export async function ensurePermission(context, request, toolName, extra = {}) {
+    if (context.autoYes)
+        return null;
+    if (isBucketGranted(context.grants, request.bucket))
+        return null;
+    if (request.bucket === 'run' &&
+        request.command &&
+        isCommandGranted(context.grants, request.command)) {
+        return null;
+    }
+    if (!context.requestPermission) {
+        return {
+            ok: false,
+            ...extra,
+            error: `requestPermission is required when autoYes is false (${toolName})`,
+        };
+    }
+    const options = buildPermissionOptions(request.bucket, request.command);
+    const decision = await context.requestPermission({ ...request, options });
+    if (decision.kind === 'deny') {
+        return declinedResponse(request.bucket, toolName, extra);
+    }
+    if (context.grants) {
+        if (decision.kind === 'always-bucket') {
+            grantBucket(context.grants, request.bucket);
+        }
+        else if (decision.kind === 'always-prefix') {
+            grantCommandPrefix(context.grants, decision.prefix);
+        }
+    }
+    return null;
+}

package/dist/src/session-safety.js

@@ -4,7 +4,6 @@ import path from 'node:path';
 import { ARTIFACT_IGNORE_DIRS, normalizeProjectRelativePath, shouldIgnoreArtifactPath, } from './artifact-policy.js';
 import { hashBytes, readFileEditSnapshot, storedContentBuffer, } from './edit-journal.js';
 import { deleteProjectFile, resolveProjectPath, writeProjectFile, writeProjectFileBuffer, } from './patcher.js';
-import { removeIndexFile, upsertIndexFile } from './project-index.js';
 const MAX_CHECKPOINTS = 20;
 const MAX_SESSION_EDITS = 500;
 const MAX_READ_RECORDS = 200;
@@ -672,7 +671,6 @@ export async function restoreCheckpointFiles(args) {
     const restored = [];
     const applied = [];
     let changed = false;
-    const syncPolicy = args.projectIndex.initialized;
     for (const snapshot of targets) {
         const before = readFileEditSnapshot(args.rootDir, snapshot.filePath);
         try {
@@ -680,15 +678,11 @@ export async function restoreCheckpointFiles(args) {
                 const result = writeStoredProjectFile(args.rootDir, snapshot.filePath, snapshot.content ?? '', snapshot.contentEncoding);
                 if (result.changed)
                     changed = true;
-                if (syncPolicy)
-                    await upsertIndexFile(args.projectIndex, snapshot.filePath);
             }
             else {
                 const result = deleteProjectFile(args.rootDir, snapshot.filePath);
                 if (result.deleted)
                     changed = true;
-                if (syncPolicy)
-                    await removeIndexFile(args.projectIndex, snapshot.filePath);
             }
             const after = readFileEditSnapshot(args.rootDir, snapshot.filePath);
             applied.push({ snapshot, before, after });
@@ -710,15 +704,9 @@ export async function restoreCheckpointFiles(args) {
                             throw new Error('previous file content is unavailable');
                         }
                         writeStoredProjectFile(args.rootDir, item.snapshot.filePath, item.before.content, item.before.contentEncoding);
-                        if (syncPolicy) {
-                            await upsertIndexFile(args.projectIndex, item.snapshot.filePath);
-                        }
                     }
                     else {
                         deleteProjectFile(args.rootDir, item.snapshot.filePath);
-                        if (syncPolicy) {
-                            await removeIndexFile(args.projectIndex, item.snapshot.filePath);
-                        }
                     }
                     rolledBack.push({ filePath: item.snapshot.filePath });
                 }

package/dist/src/session-store.js

@@ -1,12 +1,16 @@
+import { spawnSync } from 'node:child_process';
 import { createHash } from 'node:crypto';
 import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync, } from 'node:fs';
 import path from 'node:path';
 import { getClientStateDir } from './client-state.js';
+import { findStoredImageByContent, pruneSessionImages, readSessionImage, sweepOrphanSessionImages, } from './core/session-image-store.js';
+import { sweepGeneratedImages } from './tools/save-generated-image.js';
 import { normalizeAssistantEditJournal } from './edit-journal.js';
+import { createSessionGrants } from './permissions.js';
 import { cloneSessionSafetyState, createSessionSafetyState, mergeLocalSessionSafetyState, normalizeSessionSafetyState, } from './session-safety.js';
-import { truncate } from './utils.js';
+import { singleLinePreview } from './utils.js';
 const SESSION_STORE_VERSION = 1;
-const MAX_RECENT_SESSIONS = 5;
+export const MAX_RECENT_SESSIONS = 10;
 function cloneJson(value) {
     return JSON.parse(JSON.stringify(value ?? null));
 }
@@ -77,6 +81,45 @@ function listSessionFiles(rootDir, env = process.env) {
         .filter((name) => name.endsWith('.json'))
         .map((name) => path.join(dir, name));
 }
+function normalizeBranch(value) {
+    const text = String(value ?? '')
+        .replace(/[\r\n\t]/g, ' ')
+        .trim();
+    return text ? text.slice(0, 120) : null;
+}
+function dehydrateHistoryImages(history) {
+    return history.map((entry) => ({
+        ...entry,
+        parts: (entry.parts ?? []).map((part) => {
+            if (!part?.inlineData?.data)
+                return part;
+            const cachePath = part.imageCachePath ?? findStoredImageByContent(part.inlineData.data);
+            if (!cachePath)
+                return part;
+            return {
+                imageRef: { cachePath, mimeType: part.inlineData.mimeType },
+                text: '[image stored in this session]',
+            };
+        }),
+    }));
+}
+function rehydrateHistoryImages(history) {
+    return history.map((entry) => ({
+        ...entry,
+        parts: (entry.parts ?? []).map((part) => {
+            const ref = part?.imageRef;
+            if (!ref?.cachePath)
+                return part;
+            const stored = readSessionImage(String(ref.cachePath));
+            if (!stored)
+                return { text: part.text ?? '[image no longer available]' };
+            return {
+                inlineData: { mimeType: stored.mimeType, data: stored.base64Data },
+                imageCachePath: ref.cachePath,
+            };
+        }),
+    }));
+}
 function normalizeHistory(value) {
     if (!Array.isArray(value))
         return [];
@@ -107,6 +150,7 @@ function normalizeSnapshot(raw, rootDir) {
         createdAt: normalizeIsoDate(raw.createdAt),
         updatedAt: normalizeIsoDate(raw.updatedAt),
         modelId,
+        branch: normalizeBranch(raw.branch),
         history: cloneJson(normalizeHistory(raw.history)),
         clientState: sanitizeClientState(raw.clientState),
         serverState: sanitizeOpaqueState(raw.serverState),
@@ -145,14 +189,58 @@ function assertSessionNameAvailable(rootDir, name, sessionId, env = process.env)
         throw new Error(`Session name "${name}" is already used by ${duplicate.id}. Use --session "${name}" to resume it or choose a different name.`);
     }
 }
+function listAllSessionIds(env = process.env) {
+    const ids = new Set();
+    const projectsDir = path.join(getSessionBaseDir(env), 'sessions', 'projects');
+    if (!existsSync(projectsDir))
+        return ids;
+    try {
+        for (const project of readdirSync(projectsDir)) {
+            const dir = path.join(projectsDir, project);
+            try {
+                for (const file of readdirSync(dir)) {
+                    if (file.endsWith('.json'))
+                        ids.add(path.basename(file, '.json'));
+                }
+            }
+            catch {
+            }
+        }
+    }
+    catch {
+        return ids;
+    }
+    return ids;
+}
 export function pruneSavedSessions(rootDir, env = process.env) {
     const snapshots = loadAllSnapshots(rootDir, env);
     const keep = new Set(snapshots.slice(0, MAX_RECENT_SESSIONS).map((snapshot) => snapshot.id));
     for (const snapshot of snapshots.slice(MAX_RECENT_SESSIONS)) {
         if (!keep.has(snapshot.id)) {
             rmSync(getSessionPath(rootDir, snapshot.id, env), { force: true });
+            pruneSessionImages(snapshot.id, env);
         }
     }
+    sweepOrphanSessionImages({
+        activeSessionIds: listAllSessionIds(env),
+        env,
+    });
+    sweepGeneratedImages({ env });
+}
+export function readGitBranch(rootDir) {
+    try {
+        const result = spawnSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], {
+            cwd: rootDir,
+            encoding: 'utf8',
+            timeout: 1500,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        const branch = result.status === 0 ? String(result.stdout ?? '').trim() : '';
+        return branch && branch !== 'HEAD' ? branch : null;
+    }
+    catch {
+        return null;
+    }
 }
 export function snapshotFromSession(session) {
     const now = new Date().toISOString();
@@ -168,6 +256,7 @@ export function snapshotFromSession(session) {
         createdAt,
         updatedAt: now,
         modelId: session.modelId,
+        branch: readGitBranch(session.rootDir),
         history: cloneJson(session.history),
         clientState: {
             editCounter: session.clientState.editCounter,
@@ -187,6 +276,7 @@ export function saveSessionState(session, env = process.env) {
 }
 export function applySessionSnapshot(session, snapshot, options = {}) {
     const currentAgentMode = session.agentMode;
+    const previousSessionId = session.sessionId;
     session.sessionId = snapshot.id;
     session.sessionName = snapshot.name;
     session.sessionCreatedAt = snapshot.createdAt;
@@ -196,6 +286,9 @@ export function applySessionSnapshot(session, snapshot, options = {}) {
     session.serverState = sanitizeOpaqueState(snapshot.serverState);
     session.agentMode = options.preserveAgentMode ? currentAgentMode : 'default';
     session.autoYes = session.agentMode === 'auto-accept';
+    if (previousSessionId !== session.sessionId) {
+        session.grants = createSessionGrants();
+    }
     session.turnState = {
         id: null,
         historyStartIndex: session.history.length,
@@ -210,6 +303,9 @@ export function applySessionSnapshot(session, snapshot, options = {}) {
         safety: mergeLocalSessionSafetyState(session.clientState.safety, snapshot.clientState.safety),
     };
 }
+export function sessionHasUserMessage(session) {
+    return session.history.some((entry) => Boolean(userPromptText(entry)));
+}
 function extractMarkedSection(text, marker) {
     const index = text.indexOf(marker);
     if (index === -1)
@@ -218,23 +314,27 @@ function extractMarkedSection(text, marker) {
     const end = after.indexOf('\n\n');
     return (end === -1 ? after : after.slice(0, end)).trim();
 }
-function extractLastUserMessage(history) {
-    for (let i = history.length - 1; i >= 0; i--) {
-        const entry = history[i];
-        if (!entry || entry.role !== 'user')
-            continue;
-        const text = (entry.parts ?? [])
-            .map((part) => (typeof part?.text === 'string' ? part.text : ''))
-            .filter(Boolean)
-            .join('\n')
-            .trim();
-        if (!text)
-            continue;
-        const request = extractMarkedSection(text, 'Current user request:') ||
-            extractMarkedSection(text, 'User request:');
-        const message = extractMarkedSection(text, 'Current user message:') ||
-            extractMarkedSection(text, 'User message:');
-        return truncate(request || message || text, 120);
+export function userPromptText(entry) {
+    if (!entry || entry.role !== 'user' || entry.kind !== 'turnStart')
+        return '';
+    const text = (entry.parts ?? [])
+        .map((part) => (typeof part?.text === 'string' ? part.text : ''))
+        .filter(Boolean)
+        .join('\n')
+        .trim();
+    if (!text)
+        return '';
+    const request = extractMarkedSection(text, 'Current user request:') ||
+        extractMarkedSection(text, 'User request:');
+    const message = extractMarkedSection(text, 'Current user message:') ||
+        extractMarkedSection(text, 'User message:');
+    return (request || message || text).trim();
+}
+function extractFirstUserPrompt(history) {
+    for (const entry of history) {
+        const text = userPromptText(entry);
+        if (text)
+            return singleLinePreview(text, 120);
     }
     return '';
 }
@@ -247,8 +347,9 @@ function metadataFromSnapshot(snapshot) {
         updatedAt: snapshot.updatedAt,
         modelId: snapshot.modelId,
         messageCount: snapshot.history.length,
-        lastUserMessage: extractLastUserMessage(snapshot.history),
+        lastUserMessage: extractFirstUserPrompt(snapshot.history),
         summaryPreview: '',
+        branch: snapshot.branch ?? null,
     };
 }
 export function listSessionMetadata(rootDir, env = process.env) {