@thegitai/cli 1.0.0-beta.9 → 1.0.0-preview.2

package/dist/src/session-safety.js

@@ -454,17 +454,6 @@ export function resolveRedactionTokens(state, text, filePath, hash) {
 }
 const DOTENV_ASSIGNMENT_PATTERN = /^(\s*(?:export\s+)?[A-Za-z_][A-Za-z0-9_]*\s*=)(.*)$/;
 const DOTENV_COMMENT_PATTERN = /^(\s*#\s*)(\S.*)$/;
-/**
- * Redact a dotenv file's values while leaving keys visible. Every assignment's
- * value is replaced with a stable, reversible token so the agent can see the
- * file's structure and edit it (remove or replace lines) without ever seeing a
- * secret value; `resolveRedactionTokens` swaps the real values back on write.
- * Comment bodies are tokenized too, because developers routinely leave
- * commented-out credentials in dotenv files and those must not leak where the
- * opaque preview would have hidden them. Callers must confirm the content is
- * clean dotenv (`looksLikeEditableDotenv`) first so the only non-assignment
- * lines reaching here are blanks and comments.
- */
 export function redactDotenvWithStableTokens(state, content, filePath, hash) {
     const tokens = [];
     const redactedLines = content.split('\n').map((line) => {
@@ -490,14 +479,6 @@ export function redactDotenvWithStableTokens(state, content, filePath, hash) {
     });
     return { content: redactedLines.join('\n'), tokens };
 }
-/**
- * The redaction-token registry is capped at `MAX_REDACTION_TOKENS`; a read that
- * emits more tokens than that would evict its own oldest tokens, leaving
- * `[REDACTED:n]` markers in the preview that `write_file`/`str_replace` can no
- * longer resolve (silently writing the literal token back). So a dotenv file
- * with more tokenizable lines than the budget must not use the editable preview
- * — the caller falls back to the opaque blackout instead.
- */
 export function dotenvFitsRedactionBudget(content) {
     let count = 0;
     for (const line of content.split('\n')) {

package/dist/src/session-store.js

@@ -122,7 +122,6 @@ function loadAllSnapshots(rootDir, env = process.env) {
             snapshots.push(loadSnapshotFile(filePath, rootDir));
         }
         catch {
-            // Skip corrupted snapshots silently — customers have no actionable debug path here.
         }
     }
     return snapshots.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));

package/dist/src/todo-list.js

@@ -0,0 +1,106 @@
+export const MAX_TODO_ITEMS = 20;
+export const MAX_TODO_TEXT_CHARS = 160;
+let items = [];
+let activeSessionId = null;
+const STATUS_ALIASES = {
+    pending: 'pending',
+    todo: 'pending',
+    not_started: 'pending',
+    in_progress: 'in_progress',
+    active: 'in_progress',
+    doing: 'in_progress',
+    completed: 'completed',
+    complete: 'completed',
+    done: 'completed',
+};
+function normalizeStatus(raw) {
+    const key = String(raw ?? '')
+        .trim()
+        .toLowerCase()
+        .replace(/[-\s]+/g, '_');
+    return STATUS_ALIASES[key] ?? null;
+}
+export function isCompletedStatus(raw) {
+    return normalizeStatus(raw) === 'completed';
+}
+const TODOS_ARG_ALIASES = ['items', 'todo_list', 'todoList', 'list', 'tasks'];
+export function extractTodosArg(args) {
+    if (!args || typeof args !== 'object')
+        return undefined;
+    const record = args;
+    if (record.todos !== undefined)
+        return record.todos;
+    for (const key of TODOS_ARG_ALIASES) {
+        if (record[key] !== undefined)
+            return record[key];
+    }
+    return undefined;
+}
+export function setTodoSession(sessionId) {
+    const next = String(sessionId ?? '').trim() || null;
+    if (activeSessionId !== next) {
+        items = [];
+    }
+    activeSessionId = next;
+}
+export function listTodos() {
+    return items.map((item) => ({ ...item }));
+}
+export function getTodoSnapshot() {
+    return {
+        items: listTodos(),
+        completedCount: items.filter((item) => item.status === 'completed').length,
+        totalCount: items.length,
+    };
+}
+export function clearTodos() {
+    items = [];
+}
+export function replaceTodos(raw) {
+    if (!Array.isArray(raw)) {
+        return { ok: false, error: 'todos must be an array of { text, status } items.' };
+    }
+    const normalizations = [];
+    if (raw.length > MAX_TODO_ITEMS) {
+        return {
+            ok: false,
+            error: `todos supports at most ${MAX_TODO_ITEMS} items; got ${raw.length}. Use fewer, broader steps.`,
+        };
+    }
+    const next = [];
+    let sawInProgress = false;
+    for (const [index, entry] of raw.entries()) {
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+            return { ok: false, error: `todos[${index}] must be an object with text and status.` };
+        }
+        const text = String(entry.text ?? '')
+            .replace(/\s+/g, ' ')
+            .trim();
+        if (!text) {
+            return { ok: false, error: `todos[${index}].text must be a non-empty string.` };
+        }
+        const status = normalizeStatus(entry.status);
+        if (!status) {
+            return {
+                ok: false,
+                error: `todos[${index}].status must be one of: pending, in_progress, completed.`,
+            };
+        }
+        let boundedText = text;
+        if (boundedText.length > MAX_TODO_TEXT_CHARS) {
+            boundedText = `${boundedText.slice(0, MAX_TODO_TEXT_CHARS - 1)}…`;
+            normalizations.push(`todos[${index}].text truncated to ${MAX_TODO_TEXT_CHARS} chars`);
+        }
+        let finalStatus = status;
+        if (status === 'in_progress') {
+            if (sawInProgress) {
+                finalStatus = 'pending';
+                normalizations.push(`todos[${index}] demoted to pending: only one item can be in_progress`);
+            }
+            sawInProgress = true;
+        }
+        next.push({ text: boundedText, status: finalStatus });
+    }
+    items = next;
+    return { ok: true, snapshot: getTodoSnapshot(), normalizations };
+}

package/dist/src/tool-executor.js

@@ -1,8 +1,13 @@
+import { drainBackgroundJobNotifications, getBackgroundJob, } from './background-jobs.js';
 import { canStoreEditSnapshot, isEditToolName, isGitWorkTree, MAX_EDIT_JOURNAL_RECORDS, operationFromSnapshots, readFileEditSnapshot, } from './edit-journal.js';
 import { clearEditFailure, collectCommandMutations, captureMutationBaseline, ensureActiveCheckpoint, recordEditFailure, recordSessionEdit, rememberCheckpointFiles, } from './session-safety.js';
 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';
 const EDIT_FILE_PATH_ARG_ALIASES = [
     'filePath',
     'file_path',
@@ -11,6 +16,7 @@ const EDIT_FILE_PATH_ARG_ALIASES = [
     'file',
     'filename',
 ];
+const backgroundCommandTrackers = new Map();
 function toolCallSummary(call) {
     const args = call.args && typeof call.args === 'object' ? call.args : {};
     if (call.name === 'run_command') {
@@ -19,6 +25,17 @@ function toolCallSummary(call) {
     if (call.name === 'run_node_script') {
         return String(args.script ?? '').trim().slice(0, 120);
     }
+    if (call.name === 'shell_job_output' ||
+        call.name === 'shell_job_kill') {
+        return String(args.job_id ?? '').trim();
+    }
+    if (call.name === 'update_todos') {
+        const raw = extractTodosArg(args);
+        const todos = Array.isArray(raw) ? raw : [];
+        if (todos.length === 0)
+            return '';
+        return `${todos.length} item${todos.length === 1 ? '' : 's'}`;
+    }
     const filePath = getEditToolFilePath(call);
     if (filePath)
         return filePath;
@@ -45,8 +62,125 @@ function getEditToolFilePath(call) {
     }
     return '';
 }
+function editToolWritesSeparateOutput(call) {
+    if (call.name !== 'replace_document_text')
+        return false;
+    const args = call.args && typeof call.args === 'object' ? call.args : {};
+    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, }) {
+    const checkpoint = ensureActiveCheckpoint(session.clientState.safety, turnId);
+    const records = collectCommandMutations({
+        state: session.clientState.safety,
+        rootDir: session.rootDir,
+        tracker,
+        toolName,
+        toolCallId,
+        turnId,
+        checkpointId: checkpoint.id,
+    });
+    if (!records.length)
+        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.sessionEdits = records.map((record) => ({
+        id: record.id,
+        filePath: record.filePath,
+        operation: record.operation,
+        beforeHash: record.beforeHash,
+        afterHash: record.afterHash,
+    }));
+    result.diagnostics = runShellDiagnostics(session.rootDir);
+}
+export async function collectBackgroundJobUiKillMutations({ session, projectIndex, jobId, result, }) {
+    const normalizedJobId = String(jobId ?? result.snapshot?.id ?? '').trim();
+    if (!normalizedJobId || !result.ok)
+        return;
+    const tracked = backgroundCommandTrackers.get(normalizedJobId);
+    if (!tracked)
+        return;
+    const mutationResult = result;
+    await collectTrackedCommandMutations({
+        session,
+        projectIndex,
+        result: mutationResult,
+        tracker: tracked.tracker,
+        toolName: tracked.toolName,
+        toolCallId: tracked.toolCallId,
+        turnId: tracked.turnId,
+    });
+    if (result.snapshot?.status === 'running') {
+        tracked.tracker = captureMutationBaseline(session.rootDir);
+    }
+    else {
+        backgroundCommandTrackers.delete(normalizedJobId);
+    }
+}
+export async function collectBackgroundJobUiOutputMutations({ session, projectIndex, jobId, }) {
+    const normalizedJobId = String(jobId ?? '').trim();
+    if (!normalizedJobId)
+        return;
+    const tracked = backgroundCommandTrackers.get(normalizedJobId);
+    if (!tracked)
+        return;
+    const snapshot = getBackgroundJob(normalizedJobId, {
+        sessionId: session.sessionId,
+    });
+    if (!snapshot)
+        return;
+    await collectTrackedCommandMutations({
+        session,
+        projectIndex,
+        result: {},
+        tracker: tracked.tracker,
+        toolName: tracked.toolName,
+        toolCallId: tracked.toolCallId,
+        turnId: tracked.turnId,
+    });
+    if (snapshot.status === 'running') {
+        tracked.tracker = captureMutationBaseline(session.rootDir);
+    }
+    else {
+        backgroundCommandTrackers.delete(normalizedJobId);
+    }
+}
 function recordAssistantEdit(session, call, result, before) {
-    if (!before || !isEditToolName(call.name))
+    if (!before || !isEditToolName(call.name) || result?.scratch === true)
         return;
     if (!result || typeof result !== 'object' || result.ok !== true) {
         const filePath = getEditToolFilePath(call);
@@ -119,11 +253,20 @@ export async function executeLocalToolCall(toolContext, session, call) {
             session.onToolEvent?.({ call, result });
             return result;
         }
-        const filePathBeforeEdit = isEditToolName(call.name) ? getEditToolFilePath(call) : '';
-        if (filePathBeforeEdit) {
+        const rawEditFilePath = isEditToolName(call.name)
+            ? getEditToolFilePath(call)
+            : '';
+        const filePathBeforeEdit = rawEditFilePath &&
+            PATH_REPAIRING_EDIT_TOOLS.has(call.name) &&
+            !editToolWritesSeparateOutput(call)
+            ? repairFilePath(session.rootDir, rawEditFilePath)
+            : rawEditFilePath;
+        const tracksRepositoryEdit = filePathBeforeEdit &&
+            classifyProjectPath(session.rootDir, filePathBeforeEdit) === 'project';
+        if (tracksRepositoryEdit) {
             rememberCheckpointFiles(session.clientState.safety, session.rootDir, [filePathBeforeEdit], session.turnState.id);
         }
-        const beforeEditSnapshot = filePathBeforeEdit
+        const beforeEditSnapshot = tracksRepositoryEdit
             ? readFileEditSnapshot(session.rootDir, filePathBeforeEdit)
             : null;
         const commandTracker = call.name === 'run_command' || call.name === 'run_node_script'
@@ -131,6 +274,7 @@ export async function executeLocalToolCall(toolContext, session, call) {
             : null;
         const context = {
             rootDir: session.rootDir,
+            sessionId: session.sessionId,
             projectIndex: toolContext.projectIndex,
             autoYes: session.autoYes,
             confirmCommand: session.confirmCommand,
@@ -152,28 +296,57 @@ export async function executeLocalToolCall(toolContext, session, call) {
         };
         const result = await dispatchTool(context, call);
         recordAssistantEdit(session, call, result, beforeEditSnapshot);
-        if (result && commandTracker && (call.name === 'run_command' || call.name === 'run_node_script')) {
-            const checkpoint = ensureActiveCheckpoint(session.clientState.safety, session.turnState.id);
-            const records = collectCommandMutations({
-                state: session.clientState.safety,
-                rootDir: session.rootDir,
+        if (result && typeof result === 'object' && commandTracker) {
+            await collectTrackedCommandMutations({
+                session,
+                projectIndex: toolContext.projectIndex,
+                result,
                 tracker: commandTracker,
                 toolName: call.name,
                 toolCallId: call.id,
                 turnId: session.turnState.id,
-                checkpointId: checkpoint.id,
             });
-            if (records.length) {
-                invalidateShellDiagnosticsCache(session.rootDir);
-                rememberCheckpointFiles(session.clientState.safety, session.rootDir, records.map((record) => record.filePath), session.turnState.id);
-                result.sessionEdits = records.map((record) => ({
-                    id: record.id,
-                    filePath: record.filePath,
-                    operation: record.operation,
-                    beforeHash: record.beforeHash,
-                    afterHash: record.afterHash,
-                }));
-                result.diagnostics = runShellDiagnostics(session.rootDir);
+            if (call.name === 'run_command' &&
+                result.backgrounded === true &&
+                result.status === 'running' &&
+                result.jobId) {
+                backgroundCommandTrackers.set(String(result.jobId), {
+                    tracker: captureMutationBaseline(session.rootDir),
+                    toolName: call.name,
+                    toolCallId: call.id,
+                    turnId: session.turnState.id,
+                });
+            }
+        }
+        if (result &&
+            typeof result === 'object' &&
+            (call.name === 'shell_job_output' || call.name === 'shell_job_kill')) {
+            const jobId = String(result.jobId ?? call.args?.job_id ?? '').trim();
+            const tracked = backgroundCommandTrackers.get(jobId);
+            if (tracked) {
+                await collectTrackedCommandMutations({
+                    session,
+                    projectIndex: toolContext.projectIndex,
+                    result,
+                    tracker: tracked.tracker,
+                    toolName: tracked.toolName,
+                    toolCallId: tracked.toolCallId,
+                    turnId: tracked.turnId,
+                });
+                if (result.status === 'running') {
+                    tracked.tracker = captureMutationBaseline(session.rootDir);
+                }
+                else {
+                    backgroundCommandTrackers.delete(jobId);
+                }
+            }
+        }
+        if (result && typeof result === 'object') {
+            const backgroundJobUpdate = drainBackgroundJobNotifications({
+                sessionId: session.sessionId,
+            });
+            if (backgroundJobUpdate) {
+                result.backgroundJobUpdate = backgroundJobUpdate;
             }
         }
         session.onToolEvent?.({ call, result });

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

@@ -1,5 +1,5 @@
-import chalk from 'chalk';
-import { deleteProjectFile } from '../patcher.js';
+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';
@@ -9,10 +9,27 @@ export async function deleteFile(context, args) {
     if (!filePath) {
         return { ok: false, error: 'filePath is required' };
     }
+    const pathKind = classifyProjectPath(rootDir, filePath);
+    if (pathKind === 'outside') {
+        return {
+            ok: false,
+            filePath,
+            error: `Refusing to delete outside the project root: ${filePath}. Deletable locations are the project root and the session scratch directory ($THEGITAI_SCRATCH_DIR).`,
+            failureCategory: 'invalid_argument',
+            failureDetails: {
+                category: 'invalid_argument',
+                tool: 'delete_file',
+                action: 'Delete files inside the project root, or use an absolute path under the session scratch directory ($THEGITAI_SCRATCH_DIR).',
+            },
+        };
+    }
+    const scratchPath = pathKind === 'scratch';
     const result = deleteProjectFile(rootDir, filePath);
     if (result.deleted) {
-        await removeIndexFile(projectIndex, filePath);
-        invalidateShellDiagnosticsCache(rootDir, filePath);
+        if (!scratchPath) {
+            await removeIndexFile(projectIndex, filePath);
+            invalidateShellDiagnosticsCache(rootDir, filePath);
+        }
         if (!isTuiMode())
             console.log(chalk.red(`  🗑️  Deleted: ${filePath}`));
     }
@@ -21,7 +38,8 @@ export async function deleteFile(context, args) {
         filePath,
         changed: result.deleted,
         deleted: result.deleted,
+        ...(scratchPath ? { scratch: true } : {}),
         content: result.content,
-        diagnostics: result.deleted ? runShellDiagnostics(rootDir) : undefined,
+        diagnostics: result.deleted && !scratchPath ? runShellDiagnostics(rootDir) : undefined,
     };
 }

package/dist/src/tools/index.js

@@ -1,3 +1,4 @@
+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';
@@ -17,8 +18,10 @@ 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 { writeFile } from './write-file.js';
 export const TOOL_MAP = {
     search_code: (context, args) => searchCode(context.projectIndex, args),
@@ -44,6 +47,9 @@ export const TOOL_MAP = {
     undo_edit: undoEdit,
     run_command: runShellCommand,
     run_node_script: runNodeScript,
+    shell_job_output: shellJobOutput,
+    shell_job_kill: shellJobKill,
+    update_todos: updateTodos,
 };
 function invalidToolCall(error) {
     return {

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

@@ -1,15 +1,16 @@
-import chalk from 'chalk';
+import chalk from '../colors.js';
 import path from 'node:path';
 import { normalizeProjectRelativePath } from '../artifact-policy.js';
-import { applyUnifiedPatch, readProjectFile, renderDiffPreview, writeProjectFile, } from '../patcher.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';
 const DOCUMENT_EXTENSIONS = new Set(['.pdf', '.xlsx', '.docx']);
 export async function patchFile(context, args) {
     const { rootDir, projectIndex, autoYes, confirmPatch } = context;
-    const filePath = String(args.filePath ?? '').trim();
+    const filePath = repairFilePath(rootDir, String(args.filePath ?? '').trim());
     let patch = typeof args.patch === 'string' ? args.patch : '';
     if (!filePath) {
         return { ok: false, error: 'filePath is required' };
@@ -28,6 +29,21 @@ export async function patchFile(context, args) {
             failureCategory: 'invalid_argument',
         };
     }
+    const pathKind = classifyProjectPath(rootDir, filePath);
+    if (pathKind === 'outside') {
+        return {
+            ok: false,
+            filePath,
+            error: `Refusing to edit outside the project root: ${filePath}. Editable locations are the project root and the session scratch directory ($THEGITAI_SCRATCH_DIR).`,
+            failureCategory: 'invalid_argument',
+            failureDetails: {
+                category: 'invalid_argument',
+                tool: 'patch_file',
+                action: 'Edit files inside the project root, or use an absolute path under the session scratch directory ($THEGITAI_SCRATCH_DIR) for temporary files.',
+            },
+        };
+    }
+    const scratchPath = pathKind === 'scratch';
     let originalContent;
     try {
         originalContent = readProjectFile(rootDir, filePath);
@@ -67,20 +83,29 @@ export async function patchFile(context, args) {
                 ok: false,
                 skipped: true,
                 filePath,
-                error: 'User declined patch',
+                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.',
             };
         }
     }
     const { changed } = writeProjectFile(rootDir, filePath, patchedContent);
     let indexedChunks = 0;
     let retrievalTokensUsed = 0;
-    if (changed) {
+    if (changed && !scratchPath) {
         const indexResult = await upsertIndexFile(projectIndex, filePath);
         indexedChunks = indexResult.indexedChunks;
         retrievalTokensUsed = indexResult.retrievalTokensUsed ?? 0;
     }
-    invalidateShellDiagnosticsCache(rootDir, filePath);
-    const diagnostics = runShellDiagnostics(rootDir, filePath);
+    let diagnostics;
+    if (!scratchPath) {
+        invalidateShellDiagnosticsCache(rootDir, filePath);
+        diagnostics = runShellDiagnostics(rootDir, filePath);
+    }
     const originalLines = originalContent.split('\n').length;
     const patchedLines = patchedContent.split('\n').length;
     if (!isTuiMode()) {
@@ -93,6 +118,7 @@ export async function patchFile(context, args) {
         filePath,
         changed,
         operation: 'patch',
+        ...(scratchPath ? { scratch: true } : {}),
         indexedChunks,
         retrievalTokensUsed,
         bytesWritten: Buffer.byteLength(patchedContent, 'utf-8'),