mixdog 1.2.3 → 1.2.4

package/src/runtime/agent/orchestrator/session/tool-batch/finalize.mjs

@@ -15,6 +15,8 @@ import { crossTurnSignature, isEditProgressTool } from '../loop/completion-guard
 import { isEagerDispatchable, isToolCallDedupEligible, parseNativeToolSearchPayload } from '../loop/tool-helpers.mjs';
 import { restoreToolCallBodyForId } from '../loop/stored-tool-args.mjs';
 import { stageToolResult } from './state.mjs';
+import { providerConsumesReadWindows } from '../../providers/registry.mjs';
+import { remoteReadWindowReport } from '../../tools/builtin/external-tool-adapters.mjs';
 import { toolMetaPatchFromMessage } from '../transcript-restore/tool-result-status.mjs';
 import {
   compactToolResultImage,
@@ -42,12 +44,30 @@ export async function finalizeBatchResults(batch) {
   for (const state of offloadStates) {
     if (state?.result && typeof state.result === 'object') state.result = await compactResultImages(state.result);
   }
+  await reportReadWindows(batch);
   for (let index = 0; index < batch.completed.length; index += 1) {
     postProcessCompleted(batch, batch.completed[index], offloadStates[index]);
     batch.throwIfAborted();
   }
 }
 
+// A provider that declares `consumesReadWindows` (also through a remote/proxy
+// stand-in) only receives the read text. Its read results carry the
+// structured clip report next to the text, for every serving path (live,
+// eager or cached). Failure fails closed.
+async function reportReadWindows(batch) {
+  if (!providerConsumesReadWindows(batch.sessionRef?.provider)) return;
+  for (const completed of batch.completed) {
+    if (!completed.executeOk || !_isReadTool(completed.call.name)) continue;
+    try {
+      const report = await remoteReadWindowReport(completed.call.arguments, batch.cwd, completed.result);
+      if (report) completed.readWindow = report;
+    } catch {
+      completed.readWindow = { lineClipped: true };
+    }
+  }
+}
+
 // An image no provider can take is replaced by fixed text here, before it can
 // reach the transcript and fail every later send.
 const unsupportedImageText = (mimeType) => `[image omitted: ${mimeType} is not a supported image type]`;
@@ -57,7 +77,10 @@ const UNDECODABLE_IMAGE_TEXT = '[image omitted: could not be decoded]';
 // inline image is fully decoded (not only large ones); with no decoder
 // installed the image is kept as is.
 async function rejectedImageText(base64, rawMime) {
-  const mimeType = String(rawMime || 'image/png').split(';')[0].trim().toLowerCase();
+  const mimeType = String(rawMime || 'image/png')
+    .split(';')[0]
+    .trim()
+    .toLowerCase();
   if (!SUPPORTED_IMAGE_MIME_TYPES.has(mimeType)) return unsupportedImageText(mimeType);
   try {
     await resizeImageBuffer(Buffer.from(base64, 'base64'), mimeType.split('/')[1]);
@@ -73,8 +96,8 @@ async function rejectedImageText(base64, rawMime) {
 // the result reaches the read cache or the transcript; stored history is never
 // revisited.
 export async function compactResultImages(result) {
-  const parts = Array.isArray(result) ? result : Array.isArray(result?.content) ? result.content : null;
-  if (!parts) return result;
+  const parts = Array.isArray(result) ? result : result?.content;
+  if (!Array.isArray(parts)) return result;
   let changed = false;
   const next = [];
   for (const part of parts) {
@@ -101,16 +124,16 @@ export async function compactResultImages(result) {
     if (dims.originalWidth !== dims.displayWidth || dims.originalHeight !== dims.displayHeight) {
       next.push({ type: 'text', text: supersedingImageMetadataText(dims) });
     }
-    next.push(
-      source
-        ? { ...part, source: { ...source, data: compacted.data, media_type: compacted.mimeType } }
-        : {
-            ...part,
-            data: compacted.data,
-            mimeType: compacted.mimeType,
-            ...(part.mediaType ? { mediaType: compacted.mimeType } : {}),
-          }
-    );
+    if (source) {
+      next.push({ ...part, source: { ...source, data: compacted.data, media_type: compacted.mimeType } });
+    } else {
+      next.push({
+        ...part,
+        data: compacted.data,
+        mimeType: compacted.mimeType,
+        ...(part.mediaType ? { mediaType: compacted.mimeType } : {}),
+      });
+    }
   }
   if (!changed) return result;
   return Array.isArray(result) ? next : { ...result, content: next };
@@ -281,6 +304,7 @@ function completedToolResult(completed, result, postprocessStartedAt) {
     toolKind: completed.resultKind,
     toolTiming: toolTiming(completed, postprocessStartedAt),
     ...(completed.nativeToolSearch ? { nativeToolSearch: completed.nativeToolSearch } : {}),
+    ...(completed.readWindow ? { readWindow: completed.readWindow } : {}),
     ...(uiDiff !== null ? { uiDiff } : {}),
     ...toolMetaPatchFromMessage(completed.result),
   };

package/src/runtime/agent/orchestrator/session/tool-batch/pre-dispatch.mjs

@@ -3,7 +3,12 @@
 // and the repeat-failure / argument-shape guards. `skip` is the staged tool
 // message for a resolved call, or null when the call may execute.
 import { appendAgentTrace } from '../../agent-trace.mjs';
-import { _argShapeSig, _repeatFailureSig, _repeatFailurePatternWouldContinue } from '../loop/tool-classify.mjs';
+import {
+  _argShapeSig,
+  _repeatFailureSig,
+  _repeatFailurePatternWouldContinue,
+  requiresReadBody,
+} from '../loop/tool-classify.mjs';
 import { preDispatchDenyForSession } from '../loop/pre-dispatch-deny.mjs';
 import { crossTurnSignature, crossTurnDedupStub } from '../loop/completion-guards.mjs';
 import { isToolCallDedupEligible } from '../loop/tool-helpers.mjs';
@@ -27,7 +32,7 @@ export function preDispatchSkip(batch, call) {
       'error'
     );
   }
-  if (plan.duplicateCallIds.has(call.id)) {
+  if (plan.duplicateCallIds.has(call.id) && !requiresReadBody(call.name, sessionRef)) {
     const firstId = plan.dupFirstId.get(call.id);
     // Explicitly NOT a success: no tool executed for this call. 'skipped'
     // keeps the transcript/UI non-error while the unresolved-tool-failure
@@ -43,7 +48,7 @@ export function preDispatchSkip(batch, call) {
   let ctSig = null;
   if (isToolCallDedupEligible(call.name, tools)) {
     ctSig = crossTurnSignature(call.name, call.arguments);
-    const stub = crossTurnStub(batch, call, ctSig);
+    const stub = requiresReadBody(call.name, sessionRef) ? null : crossTurnStub(batch, call, ctSig);
     if (stub !== null) return skipped(stub, 'skipped', ctSig);
   }
   const sigs = {
@@ -60,7 +65,13 @@ export function preDispatchSkip(batch, call) {
 function crossTurnStub(batch, call, ctSig) {
   const prior = batch.crossTurnCalls.get(ctSig);
   if (!prior || prior.firstIteration >= batch.iterations) return null;
-  const cached = lookupToolResultReuse({ sessionId: batch.sessionId, call, cwd: batch.cwd, touch: false });
+  const cached = lookupToolResultReuse({
+    sessionId: batch.sessionId,
+    call,
+    cwd: batch.cwd,
+    touch: false,
+    sessionRef: batch.sessionRef,
+  });
   if (!cached || !prior.toolUseId || cached.entry.firstToolUseId !== prior.toolUseId) {
     batch.crossTurnCalls.delete(ctSig);
     return null;

package/src/runtime/agent/orchestrator/session/tool-schema-rejection.mjs

@@ -61,13 +61,15 @@ export function rejectedToolSchema(error, { sendTools, sessionRef, opts }) {
   const nativeCount = providerNativeToolPrefixCount(tools);
   // The wire list: the request's tools minus those the wire left out.
   const wire = tools.filter((tool) => !providerToolExclusionReason(sessionRef, tool?.name));
-  const hosted = sessionRef?.wireRoute?.wire !== 'chat' && Array.isArray(opts?.nativeTools) ? opts.nativeTools.length : 0;
+  const hosted =
+    sessionRef?.wireRoute?.wire !== 'chat' && Array.isArray(opts?.nativeTools) ? opts.nativeTools.length : 0;
   const entries = evidence(error);
   let name = '';
   for (const entry of entries) {
     const found = target(entry);
     if (!found) continue;
-    const tool = found.name ? wire.find((t) => t?.name === found.name) : wire[found.index - (found.shifted ? hosted : 0)];
+    const shift = found.shifted ? hosted : 0;
+    const tool = found.name ? wire.find((t) => t?.name === found.name) : wire[found.index - shift];
     name = typeof tool?.name === 'string' ? tool.name : '';
     if (name) break;
   }

package/src/runtime/agent/orchestrator/session/transcript-restore/restore.mjs

@@ -37,8 +37,24 @@ import {
   isTranscriptCancelledStatusText,
 } from '../../../../shared/tool-execution-contract.mjs';
 import { toolResultTerminalStatus } from '../../../../shared/tool-status.mjs';
-import { transcriptRouteMetadataFields } from '../../../../shared/transcript-metadata.mjs';
+import { transcriptAttachmentFields, transcriptRouteMetadataFields } from '../../../../shared/transcript-metadata.mjs';
 import { isImportedMessage } from '../imported-message.mjs';
+import { isContextAckMessage } from '../compact/user-message-kind.mjs';
+
+/** A failed turn's recorded end: its route, reason and quota stop, the same
+ *  fields the live turndone carries. */
+function restoredFailureFields(value) {
+  if (value.status !== 'failed') return {};
+  const errorKind = value.errorKind && typeof value.errorKind === 'object' ? value.errorKind : null;
+  const quota = value.quota && typeof value.quota === 'object' ? value.quota : null;
+  return {
+    ...transcriptRouteMetadataFields(value),
+    ...(typeof value.detail === 'string' && value.detail ? { detail: value.detail } : {}),
+    ...(typeof value.errorDetails === 'string' && value.errorDetails ? { errorDetails: value.errorDetails } : {}),
+    ...(errorKind && typeof errorKind.kind === 'string' ? { errorKind: { ...errorKind } } : {}),
+    ...(quota && typeof quota.provider === 'string' ? { quota: { ...quota } } : {}),
+  };
+}
 
 function restoredTranscriptMetadata(message) {
   const value = message?.meta?.transcript;
@@ -53,6 +69,10 @@ function restoredTranscriptMetadata(message) {
     if (typeof completionValue.checkpointId === 'string' && completionValue.checkpointId) {
       completion.checkpointId = completionValue.checkpointId;
     }
+    Object.assign(completion, restoredFailureFields(completionValue));
+    const attemptId = completionValue.attemptId || value.attemptId;
+    if (typeof attemptId === 'string' && attemptId) completion.attemptId = attemptId;
+    if (Number.isFinite(Number(completionValue.at))) completion.at = Number(completionValue.at);
   }
   return {
     // The stable message id lets a live view map a compaction's dropped
@@ -63,6 +83,9 @@ function restoredTranscriptMetadata(message) {
     ...(typeof value.sender === 'string' && value.sender ? { sender: value.sender } : {}),
     ...(typeof value.device === 'string' && value.device ? { device: value.device } : {}),
     ...(typeof value.checkpointId === 'string' && value.checkpointId ? { checkpointId: value.checkpointId } : {}),
+    // The attachments this prompt carried, by content hash: a restored row
+    // opens/downloads them by id from the attachment store.
+    ...transcriptAttachmentFields(value),
     // Skills this user turn explicitly loaded (header selection or `$name`).
     ...(Array.isArray(value.appliedSkills) && value.appliedSkills.length
       ? { appliedSkills: value.appliedSkills.filter((name) => typeof name === 'string' && name) }
@@ -71,24 +94,45 @@ function restoredTranscriptMetadata(message) {
   };
 }
 
+function restoredTurnDoneItem(completion, metadata, nextId, finalAssistantId = '') {
+  const at = Number.isFinite(completion.at) ? completion.at : metadata.at;
+  return {
+    kind: 'turndone',
+    id: nextId(),
+    ...completion,
+    ...(completion.status === 'done' && finalAssistantId ? { finalAssistantId } : {}),
+    ...(Number.isFinite(at) ? { at } : {}),
+    ...(metadata.messageId ? { messageId: metadata.messageId } : {}),
+  };
+}
+
 function restoredAssistantTranscriptItems(message, nextId) {
   const text = (typeof message?.content === 'string' ? message.content : toolResultText(message?.content)).trim();
   if (!text) return [];
   const { completion, ...metadata } = restoredTranscriptMetadata(message);
   const items = [{ kind: 'assistant', id: nextId(), text, ...metadata }];
-  if (completion) {
-    items.push({
-      kind: 'turndone',
-      id: nextId(),
-      ...completion,
-      ...(completion.status === 'done' ? { finalAssistantId: items[0].id } : {}),
-      ...(metadata.at ? { at: metadata.at } : {}),
-      ...(metadata.messageId ? { messageId: metadata.messageId } : {}),
-    });
+  // A failed end follows the message's tool calls (restoreTranscriptRange).
+  if (completion && completion.status !== 'failed') {
+    items.push(restoredTurnDoneItem(completion, metadata, nextId, items[0].id));
   }
   return items;
 }
 
+/** The failed end recorded on a message that holds no reply text before it:
+ *  the prompt itself, a tool call or a tool result. */
+function restoredFailedTurnItems(message, nextId) {
+  const { completion, ...metadata } = restoredTranscriptMetadata(message);
+  const previous = Array.isArray(message?.meta?.transcript?.previousCompletions)
+    ? message.meta.transcript.previousCompletions
+    : [];
+  const items = previous.flatMap((value) => {
+    const historical = restoredTranscriptMetadata({ meta: { transcript: { completion: value, at: value?.at } } });
+    return historical.completion ? [restoredTurnDoneItem(historical.completion, historical, nextId)] : [];
+  });
+  if (completion?.status === 'failed') items.push(restoredTurnDoneItem(completion, metadata, nextId));
+  return items;
+}
+
 // Restored tool cards: stored assistant messages keep their (compacted)
 // tool_calls and the follow-up role:'tool' results. Rebuild one transcript
 // tool item per call and attach its result by tool_call_id, so a reopened
@@ -289,13 +333,17 @@ function restoredMessageItemUpperBound(message) {
   const boundaries =
     (Array.isArray(message?.meta?.sessionInheritances) ? message.meta.sessionInheritances.length : 0) +
     (Array.isArray(message?.meta?.modelSwitches) ? message.meta.modelSwitches.length : 0);
-  if (message?.role === 'user') return 1 + boundaries;
-  if (message?.role !== 'assistant') return boundaries;
+  const completionCount =
+    Number(Boolean(message?.meta?.transcript?.completion)) +
+    (Array.isArray(message?.meta?.transcript?.previousCompletions)
+      ? message.meta.transcript.previousCompletions.length
+      : 0);
+  if (message?.role === 'user') return 1 + completionCount + boundaries;
+  if (message?.role !== 'assistant') return completionCount + boundaries;
   const calls = restoredMessageToolCalls(message);
   const content = message?.content;
   const hasContent = typeof content === 'string' ? content.length > 0 : Array.isArray(content) && content.length > 0;
-  const hasCompletion = Boolean(message?.meta?.transcript?.completion);
-  return Number(hasContent) + Number(hasCompletion) + calls.length + boundaries;
+  return Number(hasContent) + completionCount + calls.length + boundaries;
 }
 
 // One restored tool card for a parsed notification/completion envelope.
@@ -404,12 +452,14 @@ function restoreTranscriptRange(messages, start, sessionId) {
     const restoredId = () => `hist_${sessionId}_${index}_${++part}`;
     if (message?.role === 'user') {
       items.push(...restoredUserTranscriptItems(message, restoredId));
-    } else if (message?.role === 'assistant') {
+    } else if (message?.role === 'assistant' && !isContextAckMessage(message, messages[index - 1])) {
       items.push(...restoredAssistantTranscriptItems(message, restoredId));
       items.push(...restoredToolCallItems(message, restoredId, pendingToolCalls));
     } else if (message?.role === 'tool') {
       attachRestoredToolResult(message, pendingToolCalls);
     }
+    const eventStart = items.length;
+    items.push(...restoredFailedTurnItems(message, restoredId));
     for (const boundary of Array.isArray(message?.meta?.sessionInheritances) ? message.meta.sessionInheritances : []) {
       if (!boundary?.sessionId || !boundary?.provider || !boundary?.modelId) continue;
       items.push({
@@ -427,6 +477,13 @@ function restoreTranscriptRange(messages, start, sessionId) {
       if (!boundary?.provider || !boundary?.modelId) continue;
       items.push(modelSwitchItem(restoredId(), boundary));
     }
+    if (message?.meta?.transcript?.previousCompletions?.length) {
+      const events = items.slice(eventStart);
+      if (events.every((item) => Number.isFinite(item.at))) {
+        events.sort((left, right) => left.at - right.at);
+        items.splice(eventStart, events.length, ...events);
+      }
+    }
   }
   return mergeRestoredToolItems(items);
 }

package/src/runtime/agent/orchestrator/session/turn-failure.mjs

@@ -0,0 +1,45 @@
+// The failed-turn record shared by the live turn close (tui/session/turn.mjs)
+// and the durable turn end (manager/ask-turn-failure.mjs), so a reopened
+// session shows the same failure, reason and quota stop as the live one.
+import { errText } from '../../../shared/err-text.mjs';
+import { safeErrorDetails } from '../../../shared/error-presentation.mjs';
+import { providerErrorKind } from '../providers/provider-error-kind.mjs';
+import { toolErrorDisplay } from './transcript-restore/tool-result-text.mjs';
+
+/**
+ * `{ providerKind, errorKind, quota, detail, errorDetails }` for one turn
+ * error. `quota` is null unless the pool validated an exhaustion or the
+ * provider named the real reset time; `route` fills its provider/model.
+ */
+export function turnFailureRecord(error, route = {}) {
+  // Presentation only: legacy untyped failure text may still name a usage limit.
+  const providerKind = providerErrorKind(error, { legacyQuotaWording: true });
+  const errorKind = {
+    kind: providerKind.kind,
+    code: providerKind.code,
+    status: providerKind.status,
+    retryAfterMs: providerKind.retryAfterMs,
+    resetAt: providerKind.resetAt,
+  };
+  const exhausted = error?.quotaExhausted;
+  const resetKnown = providerKind.kind === 'quota_exhausted' && Number.isFinite(providerKind.resetAt);
+  let quota = null;
+  if ((exhausted && typeof exhausted === 'object') || resetKnown) {
+    const source = exhausted && typeof exhausted === 'object' ? exhausted : {};
+    let resetAt = null;
+    if (Number.isFinite(source.resetAt)) resetAt = source.resetAt;
+    else if (Number.isFinite(providerKind.resetAt)) resetAt = providerKind.resetAt;
+    quota = {
+      provider: String(source.provider || route.provider || ''),
+      model: String(source.model || route.model || ''),
+      resetAt,
+    };
+  }
+  return {
+    providerKind,
+    errorKind,
+    quota,
+    detail: toolErrorDisplay(error, 'turn').replace(/^Error:\s*/i, ''),
+    errorDetails: safeErrorDetails(errText(error)),
+  };
+}

package/src/runtime/agent/orchestrator/stall-policy.mjs

@@ -259,6 +259,56 @@ export const PROVIDER_WS_SEMANTIC_IDLE_TIMEOUT_MS = resolveTimeoutMs(
   { minMs: 10_000, maxMs: Math.max(10_000, STALL_ABORT_MS - STALL_TICK_MS) }
 );
 
+/**
+ * The longest a provider's own first-byte handling may legitimately run
+ * before it gives up, over every attempt it permits: `windowMs(n)` is the wait
+ * of attempt n, applied to the response headers and again to the first chunk,
+ * and `backoffMs[n]` the sleep before attempt n (index 0 unused, the last
+ * value repeats). `transportMs` covers the header stage only; `semanticMs`
+ * covers headers plus first chunk. The agent watchdog's first-response
+ * deadlines sit above these, so the provider's timeout and retry decide first.
+ */
+export function providerFirstResponseBudget({ attempts, windowMs, backoffMs = [] }) {
+  let transportMs = 0;
+  let semanticMs = 0;
+  for (let attempt = 0; attempt < Math.max(1, attempts); attempt++) {
+    const backoff = attempt > 0 ? (backoffMs[Math.min(attempt, backoffMs.length - 1)] ?? 0) : 0;
+    const window = windowMs(attempt);
+    transportMs += backoff + window;
+    semanticMs += backoff + 2 * window;
+  }
+  return { transportMs, semanticMs };
+}
+
+/**
+ * A provider's first-byte policy `{ timeoutMs, maxMs, retries }`: `timeoutMs`
+ * is the first attempt's window (headers, and again the first chunk); each
+ * first-byte timeout doubles the next window up to `maxMs`, and `retries` caps
+ * how many of those timeouts are retried. `retries: null` leaves first-byte
+ * timeouts to the provider's ordinary ladder, every attempt on `timeoutMs`.
+ * Returns the window of an attempt after `timeouts` first-byte timeouts.
+ */
+export function firstByteWindowMs(policy, timeouts = 0) {
+  if (policy.retries == null) return policy.timeoutMs;
+  return Math.min(policy.timeoutMs * 2 ** timeouts, Math.max(policy.timeoutMs, policy.maxMs));
+}
+
+/**
+ * providerFirstResponseBudget for a first-byte policy over a ladder of
+ * `attempts` sends. Connection drops and 5xx responses share that ladder with
+ * first-byte timeouts, and such a failure can land just before the timeout, so
+ * every attempt is budgeted a full window. A window only grows with the
+ * timeouts before it and at most `retries` timeouts are retried, so the worst
+ * case has the timeouts first, then later attempts at the widest window.
+ */
+export function firstBytePolicyBudget(policy, { attempts, backoffMs }) {
+  return providerFirstResponseBudget({
+    attempts,
+    windowMs: (attempt) => firstByteWindowMs(policy, Math.min(attempt, policy.retries ?? 0)),
+    backoffMs,
+  });
+}
+
 // First retry has a small floor (250ms) instead of 0ms: an immediate reissue on
 // a transient 5xx burst lets parallel workers thundering-herd the backend in
 // lockstep (jitter alone can't decluster a 0ms base). Subsequent steps keep the

package/src/runtime/agent/orchestrator/tools/builtin/bash-tool/completed-result.mjs

@@ -1,5 +1,6 @@
 import { renderBackgroundTask, startBackgroundTask } from '../../../../../shared/background-tasks.mjs';
 import { killShellDescendants, waitForShellDescendants } from '../../lib/shell-descendants.mjs';
+import { releaseShellJobWorkspace } from '../lib/shell-job-records.mjs';
 import { consumeFilterTeeCapture } from '../shell-analysis.mjs';
 import { compactShellOutputLosslessly, renderShellOutputBody } from '../shell-lossless-compact.mjs';
 import { removeTransportFileNow } from './transport-artifacts.mjs';
@@ -33,7 +34,10 @@ function trackSurvivingDescendants(handle, { command, cwd, options, startedAtMs
       meta: { task_id: handle.taskId, stdout: null, stderr: null, cwd, timeoutMs: 0 },
       resultType: 'shell_task_result',
       run: async () => {
-        await waitForShellDescendants(handle, { pollMs: 1_000 });
+        await waitForShellDescendants(handle);
+        // The folder reservation the finished command handed to its
+        // survivors ends with the last of them.
+        releaseShellJobWorkspace(handle.taskId);
         return {
           task_id: handle.taskId,
           status: 'completed',

package/src/runtime/agent/orchestrator/tools/builtin/bash-tool/inline-hoist.mjs

@@ -1,3 +1,4 @@
+import { randomUUID } from 'node:crypto';
 import { writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join as pathJoin } from 'node:path';
@@ -23,12 +24,15 @@ export function hoistInlineScript(command, shellType) {
     planLongShellScriptFileTransport(command, transport);
   if (!hoist) return { command, hoistPath: null };
   try {
-    const file = pathJoin(tmpdir(), `mixdog-inline-${process.pid}-${Date.now().toString(36)}${hoist.extension}`);
+    // One file per command: parallel calls start within the same millisecond,
+    // and a shared name let a later script overwrite an earlier one before it
+    // ran. The exclusive flag refuses any name that already exists.
+    const file = pathJoin(tmpdir(), `mixdog-inline-${process.pid}-${randomUUID()}${hoist.extension}`);
     // Windows PowerShell 5.1 interprets UTF-8 without BOM as the active ANSI
     // codepage. Preserve non-ASCII command text when the transport changes a
     // long command into a .ps1 file.
     const fileBody = hoist.extension === '.ps1' ? `\uFEFF${hoist.body}` : hoist.body;
-    writeFileSync(file, fileBody, 'utf8');
+    writeFileSync(file, fileBody, { encoding: 'utf8', flag: 'wx' });
     return { command: hoist.replace(file.replace(/\\/g, '/')), hoistPath: file };
   } catch {
     return { command, hoistPath: null };