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

package/dist/src/session.js

@@ -1,5 +1,6 @@
 import path from 'node:path';
 import { normalizeAgentMode, } from './agent-mode.js';
+import { createSessionGrants, } from './permissions.js';
 import { createSessionSafetyState, } from './session-safety.js';
 import { clampInteger } from './utils.js';
 const DEFAULT_MAX_TOOL_STEPS = 32;
@@ -31,7 +32,7 @@ function preserveProviderSelection(serverState) {
         : null;
     return providerSelection ? { providerSelection } : {};
 }
-export function createSession({ rootDir, autoYes = false, agentMode, modelId, maxToolSteps = DEFAULT_MAX_TOOL_STEPS, confirmCommand = null, confirmPatch = null, requestSudoPassword = null, onStatus = null, onContextLog = null, onToolEvent = null, env = process.env, sessionId = createSessionId(), sessionName = null, history = [], serverState = null, editJournal = [], stickyFilePaths = [], editCounter = 0, safety = createSessionSafetyState(), }) {
+export function createSession({ rootDir, autoYes = false, agentMode, modelId, maxToolSteps = DEFAULT_MAX_TOOL_STEPS, requestPermission = null, requestSudoPassword = null, requestUserInput = null, onStatus = null, onContextLog = null, onToolEvent = null, env = process.env, sessionId = createSessionId(), sessionName = null, history = [], serverState = null, editJournal = [], stickyFilePaths = [], editCounter = 0, safety = createSessionSafetyState(), }) {
     const createdAt = new Date().toISOString();
     const initialAgentMode = normalizeAgentMode(agentMode ?? (autoYes ? 'auto-accept' : 'default'));
     return {
@@ -43,9 +44,10 @@ export function createSession({ rootDir, autoYes = false, agentMode, modelId, ma
         onStatus: onStatus ?? defaultStatus,
         onContextLog: onContextLog ?? defaultContextLog,
         onToolEvent,
-        confirmCommand,
-        confirmPatch,
+        grants: createSessionGrants(),
+        requestPermission,
         requestSudoPassword,
+        requestUserInput,
         history: JSON.parse(JSON.stringify(history)),
         initialized: true,
         sessionId,
@@ -69,8 +71,17 @@ export function createSession({ rootDir, autoYes = false, agentMode, modelId, ma
         serverState: cloneOpaqueState(serverState),
     };
 }
+export function startNewConversation(session) {
+    clearConversation(session);
+    const createdAt = new Date().toISOString();
+    session.sessionId = createSessionId();
+    session.sessionName = null;
+    session.sessionCreatedAt = createdAt;
+    session.sessionUpdatedAt = createdAt;
+}
 export function clearConversation(session) {
     session.history = [];
+    session.grants = createSessionGrants();
     session.serverState = preserveProviderSelection(session.serverState);
     session.turnState = {
         id: null,

package/dist/src/signin.js

@@ -0,0 +1,58 @@
+import { stdin as input, stdout as output } from 'node:process';
+import readline from 'node:readline/promises';
+import chalk from './colors.js';
+import { auth } from './api/index.js';
+import { DEFAULT_THEGITAI_HOST } from './api/default-host.js';
+import { loginViaBrowser } from './api/browser-login.js';
+function hyperlink(url, label) {
+    if (process.stdout.isTTY !== true)
+        return label;
+    return `\x1b]8;;${url}\x07${label}\x1b]8;;\x07`;
+}
+export function formatSignInScreen({ url }) {
+    return [
+        '',
+        `  ${chalk.bold.cyan('TheGitAI')}`,
+        '',
+        `  ${chalk.bold('Sign in to continue.')}`,
+        '  Your browser should open automatically. If not, copy this URL:',
+        '',
+        `  ${chalk.cyan(url)}`,
+        '',
+        `  ${hyperlink(url, chalk.cyan('→ Click here to authenticate'))}`,
+        '',
+        '  If this terminal is not on the computer where that page opened, choose',
+        `  ${chalk.bold('"On another computer"')} there and paste the code it gives you below.`,
+        '',
+    ].join('\n');
+}
+async function promptForCode(signal) {
+    const rl = readline.createInterface({ input, output });
+    try {
+        return await rl.question(`  ${chalk.bold('Authorization code:')} `, { signal });
+    }
+    finally {
+        rl.close();
+    }
+}
+export async function runSignIn({ env = process.env, login = loginViaBrowser, write = auth.writeCliAuthConfig, log = (line) => console.log(line), } = {}) {
+    const result = await login({
+        serverUrl: DEFAULT_THEGITAI_HOST,
+        deviceName: env.THEGITAI_DEVICE_NAME?.trim() || undefined,
+        onUrl: (url) => log(formatSignInScreen({ url })),
+        onBrowserOpen: (opened) => {
+            if (!opened) {
+                log(chalk.dim('  (no browser opened — use the URL or the code box above)'));
+            }
+        },
+        promptCode: promptForCode,
+        onPasteRejected: (message) => log(`  ${chalk.red('✖')} ${message}\n` +
+            '    Codes last 10 minutes. If that page has been open a while, run `ai`\n' +
+            '    again for a fresh one.'),
+    });
+    write(result, env);
+    log('');
+    log(chalk.green(`  ✓ Signed in as ${result.customer.email}`));
+    log('');
+    return result;
+}

package/dist/src/tool-executor.js

@@ -4,7 +4,6 @@ import { clearEditFailure, collectCommandMutations, captureMutationBaseline, ens
 import { buildAgentModeToolBlockedResult, } from './agent-mode.js';
 import { classifyProjectPath } from './patcher.js';
 import { dispatchTool } from './tools/index.js';
-import { syncIndexFromDisk } from './project-index.js';
 import { PATH_REPAIRING_EDIT_TOOLS, repairFilePath } from './tools/path-suggest.js';
 import { invalidateShellDiagnosticsCache, runShellDiagnostics, } from './tools/shell-diagnostics.js';
 import { extractTodosArg } from './todo-list.js';
@@ -69,7 +68,7 @@ function editToolWritesSeparateOutput(call) {
     const output = args.outputPath ?? args.output_path;
     return typeof output === 'string' && output.trim().length > 0;
 }
-async function collectTrackedCommandMutations({ session, projectIndex, result, tracker, toolName, toolCallId, turnId, }) {
+async function collectTrackedCommandMutations({ session, result, tracker, toolName, toolCallId, turnId, }) {
     const checkpoint = ensureActiveCheckpoint(session.clientState.safety, turnId);
     const records = collectCommandMutations({
         state: session.clientState.safety,
@@ -84,40 +83,11 @@ async function collectTrackedCommandMutations({ session, projectIndex, result, t
         return;
     invalidateShellDiagnosticsCache(session.rootDir);
     rememberCheckpointFiles(session.clientState.safety, session.rootDir, records.map((record) => record.filePath), turnId);
-    const priorSync = result.repoSync;
-    if (!(priorSync && (priorSync.added || priorSync.modified || priorSync.removed))) {
-        const mutationCounts = {
-            added: records.filter((record) => record.operation === 'create').length,
-            modified: records.filter((record) => record.operation === 'update').length,
-            removed: records.filter((record) => record.operation === 'delete').length,
-            indexedChunks: 0,
-            retrievalTokensUsed: 0,
-        };
-        if (priorSync?.error) {
-            result.repoSync = {
-                ...mutationCounts,
-                indexSyncError: priorSync.error,
-                skipped: true,
-                reason: 'local index sync failed after command execution',
-            };
-        }
-        else {
-            try {
-                const repoSync = await syncIndexFromDisk(projectIndex);
-                result.repoSync = {
-                    ...repoSync,
-                    added: Math.max(repoSync.added, mutationCounts.added),
-                    modified: Math.max(repoSync.modified, mutationCounts.modified),
-                    removed: Math.max(repoSync.removed, mutationCounts.removed),
-                };
-            }
-            catch (error) {
-                const indexSyncError = error instanceof Error ? error.message : String(error);
-                result.repoSync = { ...mutationCounts, indexSyncError };
-                session.onStatus(`Repository changes were recorded, but local index sync failed: ${indexSyncError}`);
-            }
-        }
-    }
+    result.repoSync = {
+        added: records.filter((record) => record.operation === 'create').length,
+        modified: records.filter((record) => record.operation === 'update').length,
+        removed: records.filter((record) => record.operation === 'delete').length,
+    };
     result.sessionEdits = records.map((record) => ({
         id: record.id,
         filePath: record.filePath,
@@ -127,7 +97,7 @@ async function collectTrackedCommandMutations({ session, projectIndex, result, t
     }));
     result.diagnostics = runShellDiagnostics(session.rootDir);
 }
-export async function collectBackgroundJobUiKillMutations({ session, projectIndex, jobId, result, }) {
+export async function collectBackgroundJobUiKillMutations({ session, jobId, result, }) {
     const normalizedJobId = String(jobId ?? result.snapshot?.id ?? '').trim();
     if (!normalizedJobId || !result.ok)
         return;
@@ -137,7 +107,6 @@ export async function collectBackgroundJobUiKillMutations({ session, projectInde
     const mutationResult = result;
     await collectTrackedCommandMutations({
         session,
-        projectIndex,
         result: mutationResult,
         tracker: tracked.tracker,
         toolName: tracked.toolName,
@@ -151,7 +120,7 @@ export async function collectBackgroundJobUiKillMutations({ session, projectInde
         backgroundCommandTrackers.delete(normalizedJobId);
     }
 }
-export async function collectBackgroundJobUiOutputMutations({ session, projectIndex, jobId, }) {
+export async function collectBackgroundJobUiOutputMutations({ session, jobId, }) {
     const normalizedJobId = String(jobId ?? '').trim();
     if (!normalizedJobId)
         return;
@@ -165,7 +134,6 @@ export async function collectBackgroundJobUiOutputMutations({ session, projectIn
         return;
     await collectTrackedCommandMutations({
         session,
-        projectIndex,
         result: {},
         tracker: tracked.tracker,
         toolName: tracked.toolName,
@@ -244,7 +212,7 @@ function recordAssistantEdit(session, call, result, before) {
     });
     clearEditFailure(session.clientState.safety, filePath);
 }
-export async function executeLocalToolCall(toolContext, session, call) {
+export async function executeLocalToolCall(session, call) {
     session.onStatus(formatToolCallForStatus(call));
     try {
         const agentModeBlocked = buildAgentModeToolBlockedResult(session.agentMode, call);
@@ -275,10 +243,9 @@ export async function executeLocalToolCall(toolContext, session, call) {
         const context = {
             rootDir: session.rootDir,
             sessionId: session.sessionId,
-            projectIndex: toolContext.projectIndex,
             autoYes: session.autoYes,
-            confirmCommand: session.confirmCommand,
-            confirmPatch: session.confirmPatch,
+            grants: session.grants,
+            requestPermission: session.requestPermission,
             requestSudoPassword: session.requestSudoPassword,
             onStatus: session.onStatus,
             editJournal: session.clientState.editJournal,
@@ -299,7 +266,6 @@ export async function executeLocalToolCall(toolContext, session, call) {
         if (result && typeof result === 'object' && commandTracker) {
             await collectTrackedCommandMutations({
                 session,
-                projectIndex: toolContext.projectIndex,
                 result,
                 tracker: commandTracker,
                 toolName: call.name,
@@ -326,7 +292,6 @@ export async function executeLocalToolCall(toolContext, session, call) {
             if (tracked) {
                 await collectTrackedCommandMutations({
                     session,
-                    projectIndex: toolContext.projectIndex,
                     result,
                     tracker: tracked.tracker,
                     toolName: tracked.toolName,

package/dist/src/tools/delete-file.js

@@ -1,10 +1,10 @@
 import chalk from '../colors.js';
 import { classifyProjectPath, deleteProjectFile } from '../patcher.js';
 import { isTuiMode } from '../runtime-mode.js';
-import { removeIndexFile } from '../project-index.js';
 import { invalidateShellDiagnosticsCache, runShellDiagnostics, } from './shell-diagnostics.js';
+import { ensurePermission } from '../permissions.js';
 export async function deleteFile(context, args) {
-    const { rootDir, projectIndex } = context;
+    const { rootDir } = context;
     const filePath = String(args.filePath ?? '').trim();
     if (!filePath) {
         return { ok: false, error: 'filePath is required' };
@@ -24,10 +24,22 @@ export async function deleteFile(context, args) {
         };
     }
     const scratchPath = pathKind === 'scratch';
+    if (!scratchPath) {
+        const denied = await ensurePermission(context, {
+            bucket: 'delete',
+            title: 'Approve file deletion?',
+            body: `Delete ${filePath}`,
+            filePath,
+        }, 'delete_file', { filePath });
+        if (denied) {
+            if (!isTuiMode())
+                console.log(chalk.dim(`  ⏭  Delete skipped: ${filePath}`));
+            return denied;
+        }
+    }
     const result = deleteProjectFile(rootDir, filePath);
     if (result.deleted) {
         if (!scratchPath) {
-            await removeIndexFile(projectIndex, filePath);
             invalidateShellDiagnosticsCache(rootDir, filePath);
         }
         if (!isTuiMode())

package/dist/src/tools/index.js

@@ -1,14 +1,11 @@
 import { shellJobOutput } from './shell-job-output.js';
 import { deleteFile } from './delete-file.js';
-import { findSymbol } from './find-symbol.js';
 import { getDiagnostics } from './get-diagnostics.js';
 import { grepCode } from './grep-code.js';
-import { hoverSymbol } from './hover-symbol.js';
 import { listDirectories } from './list-directories.js';
 import { listCheckpoints } from './list-checkpoints.js';
 import { listFiles } from './list-files.js';
 import { listSessionEdits } from './list-session-edits.js';
-import { listSymbols } from './list-symbols.js';
 import { patchFile } from './patch-file.js';
 import { readDocument } from './read-document.js';
 import { readFile } from './read-file.js';
@@ -16,25 +13,20 @@ import { replaceDocumentText } from './replace-document-text.js';
 import { runShellCommand } from './run-command.js';
 import { runNodeScript } from './run-node-script.js';
 import { restoreFilesToCheckpoint, restoreToCheckpoint, } from './restore-checkpoint.js';
-import { searchCode } from './search-code.js';
-import { getSignatureHelp } from './signature-help.js';
 import { shellJobKill } from './shell-job-kill.js';
 import { strReplace } from './str-replace.js';
 import { undoEdit } from './undo-edit.js';
 import { updateTodos } from './update-todos.js';
+import { readImageFile } from './read-image-file.js';
+import { saveGeneratedImage } from './save-generated-image.js';
 import { writeFile } from './write-file.js';
 export const TOOL_MAP = {
-    search_code: (context, args) => searchCode(context.projectIndex, args),
     list_files: (context, args) => listFiles(context, args),
     list_directories: (context, args) => listDirectories(context, args),
     read_file: (context, args) => readFile(context, args),
     read_document: (context, args) => readDocument(context.rootDir, args, context.env),
     replace_document_text: replaceDocumentText,
     grep_code: (context, args) => grepCode(context.rootDir, args),
-    find_symbol: (context, args) => findSymbol(context, args),
-    list_symbols: (context, args) => listSymbols(context, args),
-    hover_symbol: (context, args) => hoverSymbol(context, args),
-    signature_help: (context, args) => getSignatureHelp(context, args),
     get_diagnostics: (context, args) => getDiagnostics(context, args),
     list_checkpoints: (context) => listCheckpoints(context),
     list_session_edits: (context) => listSessionEdits(context),
@@ -50,6 +42,17 @@ export const TOOL_MAP = {
     shell_job_output: shellJobOutput,
     shell_job_kill: shellJobKill,
     update_todos: updateTodos,
+    analyze_image: (context, args) => readImageFile(context, args),
+    generate_image: (_context, args) => {
+        if (!String(args.base64Data ?? '').trim()) {
+            return {
+                ok: false,
+                error: 'This CLI build cannot generate images without server-supplied image bytes. Update TheGitAI CLI.',
+                failureCategory: 'tool_exception',
+            };
+        }
+        return saveGeneratedImage(args);
+    },
 };
 function invalidToolCall(error) {
     return {

package/dist/src/tools/patch-file.js

@@ -2,14 +2,14 @@ import chalk from '../colors.js';
 import path from 'node:path';
 import { normalizeProjectRelativePath } from '../artifact-policy.js';
 import { applyUnifiedPatch, classifyProjectPath, readProjectFile, renderDiffPreview, writeProjectFile, } from '../patcher.js';
-import { upsertIndexFile } from '../project-index.js';
 import { repairFilePath } from './path-suggest.js';
 import { isTuiMode } from '../runtime-mode.js';
 import { getCurrentFileHash, resolveRedactionTokens } from '../session-safety.js';
 import { invalidateShellDiagnosticsCache, runShellDiagnostics, } from './shell-diagnostics.js';
+import { ensurePermission } from '../permissions.js';
 const DOCUMENT_EXTENSIONS = new Set(['.pdf', '.xlsx', '.docx']);
 export async function patchFile(context, args) {
-    const { rootDir, projectIndex, autoYes, confirmPatch } = context;
+    const { rootDir } = context;
     const filePath = repairFilePath(rootDir, String(args.filePath ?? '').trim());
     let patch = typeof args.patch === 'string' ? args.patch : '';
     if (!filePath) {
@@ -74,33 +74,21 @@ export async function patchFile(context, args) {
         };
     }
     renderDiffPreview(filePath, patch);
-    if (!autoYes && confirmPatch) {
-        const confirmed = await confirmPatch(filePath, patch);
-        if (!confirmed) {
+    if (!scratchPath) {
+        const denied = await ensurePermission(context, {
+            bucket: getCurrentFileHash(rootDir, filePath) === null ? 'create' : 'edit',
+            title: 'Approve patch?',
+            body: 'Review changes before applying.',
+            filePath,
+            diff: patch,
+        }, 'patch_file', { filePath });
+        if (denied) {
             if (!isTuiMode())
                 console.log(chalk.dim(`  ⏭  Patch skipped: ${filePath}`));
-            return {
-                ok: false,
-                skipped: true,
-                filePath,
-                failureCategory: 'user_declined',
-                failureDetails: {
-                    category: 'user_declined',
-                    tool: 'patch_file',
-                    action: 'Respect the real user’s decision. Do not retry the same or an equivalent edit; reconsider the approach or ask one specific question if needed.',
-                },
-                error: 'The real user rejected this proposed patch. Nothing was changed; this was not a tool failure or an automated system skip.',
-            };
+            return denied;
         }
     }
     const { changed } = writeProjectFile(rootDir, filePath, patchedContent);
-    let indexedChunks = 0;
-    let retrievalTokensUsed = 0;
-    if (changed && !scratchPath) {
-        const indexResult = await upsertIndexFile(projectIndex, filePath);
-        indexedChunks = indexResult.indexedChunks;
-        retrievalTokensUsed = indexResult.retrievalTokensUsed ?? 0;
-    }
     let diagnostics;
     if (!scratchPath) {
         invalidateShellDiagnosticsCache(rootDir, filePath);
@@ -119,8 +107,6 @@ export async function patchFile(context, args) {
         changed,
         operation: 'patch',
         ...(scratchPath ? { scratch: true } : {}),
-        indexedChunks,
-        retrievalTokensUsed,
         bytesWritten: Buffer.byteLength(patchedContent, 'utf-8'),
         diagnostics,
     };

package/dist/src/tools/read-image-file.js

@@ -0,0 +1,85 @@
+import path from 'node:path';
+import { normalizeProjectRelativePath } from '../artifact-policy.js';
+import { SessionImageError, getImageStoreSession, isSessionStorePath, readSessionImage, readSessionImageByIndex, storeSessionImageFromPath, } from '../core/session-image-store.js';
+export async function readImageFile(context, args) {
+    const rawPath = String(args.path ?? args.filePath ?? args.file_path ?? '').trim();
+    if (!rawPath) {
+        const requested = Number(args.imageIndex ?? args.image_index ?? args.index);
+        const stored = Number.isInteger(requested)
+            ? readSessionImageByIndex(requested)
+            : null;
+        if (!stored) {
+            return {
+                ok: false,
+                error: Number.isInteger(requested)
+                    ? `Image #${requested} is not in this session's image store.`
+                    : 'path is required and must name an image file on this machine.',
+                failureCategory: Number.isInteger(requested)
+                    ? 'not_found'
+                    : 'missing_required_argument',
+            };
+        }
+        return {
+            ok: true,
+            imageBytes: {
+                base64Data: stored.base64Data,
+                mimeType: stored.mimeType,
+                cachePath: stored.cachePath,
+                index: stored.index,
+            },
+        };
+    }
+    let resolved;
+    if (path.isAbsolute(rawPath)) {
+        resolved = rawPath;
+    }
+    else if (normalizeProjectRelativePath(context.rootDir, rawPath)) {
+        resolved = path.resolve(context.rootDir, rawPath);
+    }
+    else {
+        return {
+            ok: false,
+            error: `Refusing to access path outside the project root: ${rawPath}`,
+            failureCategory: 'permission_denied',
+        };
+    }
+    try {
+        const stored = isSessionStorePath(resolved)
+            ? readSessionImage(resolved)
+            : storeSessionImageFromPath({
+                sessionId: getImageStoreSession() ?? 'unbound',
+                sourcePath: resolved,
+            });
+        if (!stored) {
+            return {
+                ok: false,
+                error: `Not a readable image: ${resolved}`,
+                failureCategory: 'not_found',
+            };
+        }
+        return {
+            ok: true,
+            imageBytes: {
+                base64Data: stored.base64Data,
+                mimeType: stored.mimeType,
+                filePath: resolved,
+                cachePath: stored.cachePath,
+                index: stored.index,
+            },
+        };
+    }
+    catch (err) {
+        if (err instanceof SessionImageError) {
+            return {
+                ok: false,
+                error: err.message,
+                failureCategory: err.code === 'NOT_FOUND' ? 'not_found' : 'invalid_argument',
+            };
+        }
+        return {
+            ok: false,
+            error: `Could not read image: ${err?.message ?? err}`,
+            failureCategory: 'tool_exception',
+        };
+    }
+}

package/dist/src/tools/replace-document-text.js

@@ -6,6 +6,8 @@ import { readCliAuthConfig } from '../api/auth.js';
 import { resolveProjectPath, writeProjectFileBuffer } from '../patcher.js';
 import { repairFilePath, suggestClosestPath } from './path-suggest.js';
 import { isTuiMode } from '../runtime-mode.js';
+import { ensurePermission } from '../permissions.js';
+import { getCurrentFileHash } from '../session-safety.js';
 function normalizeReplacements(value) {
     if (!Array.isArray(value))
         return [];
@@ -178,27 +180,35 @@ export async function replaceDocumentText(context, args) {
     }
     const preview = String(serverResult.preview ?? '');
     renderPreview(targetPath, preview);
-    if (!context.autoYes && context.confirmPatch) {
-        const confirmed = await context.confirmPatch(targetPath, preview);
-        if (!confirmed) {
-            if (!isTuiMode()) {
-                console.log(chalk.dim(`  replace_document_text skipped: ${targetPath}`));
-            }
-            return {
-                ok: false,
-                skipped: true,
-                filePath: targetPath,
-                failureCategory: 'user_declined',
-                failureDetails: {
-                    category: 'user_declined',
-                    tool: 'replace_document_text',
-                    action: 'Respect the real user’s decision. Do not retry the same or an equivalent edit; reconsider the approach or ask one specific question if needed.',
-                },
-                error: 'The real user rejected this proposed document edit. Nothing was changed; this was not a tool failure or an automated system skip.',
-            };
+    const targetHashBeforeApproval = getCurrentFileHash(context.rootDir, targetPath);
+    const documentIsNew = targetHashBeforeApproval === null;
+    const denied = await ensurePermission(context, {
+        bucket: documentIsNew ? 'create' : 'edit',
+        title: documentIsNew ? 'Approve new document?' : 'Approve document edit?',
+        body: 'Review changes before applying.',
+        filePath: targetPath,
+        diff: preview,
+    }, 'replace_document_text', { filePath: targetPath });
+    if (denied) {
+        if (!isTuiMode()) {
+            console.log(chalk.dim(`  replace_document_text skipped: ${targetPath}`));
         }
+        return denied;
     }
     const fileData = String(serverResult.fileData ?? '');
+    if (getCurrentFileHash(context.rootDir, targetPath) !== targetHashBeforeApproval) {
+        return {
+            ok: false,
+            filePath: targetPath,
+            failureCategory: 'conflict',
+            error: `replace_document_text refused: ${targetPath} changed on disk while the approval prompt was open.`,
+            failureDetails: {
+                category: 'conflict',
+                tool: 'replace_document_text',
+                action: 'Re-read the document to see its current contents, then rebuild the replacements against it and retry.',
+            },
+        };
+    }
     const nextData = Buffer.from(fileData, 'base64');
     const write = writeProjectFileBuffer(context.rootDir, targetPath, nextData);
     const failedCount = Number(serverResult.failedCount ?? 0);

package/dist/src/tools/restore-checkpoint.js

@@ -54,7 +54,6 @@ export async function restoreToCheckpoint(context, args) {
     const result = await restoreCheckpointFiles({
         state: context.safety,
         rootDir: context.rootDir,
-        projectIndex: context.projectIndex,
         checkpointId,
         filePaths,
         currentTurnId: context.currentTurnId ?? null,