@narumitw/pi-sync 0.57.2 → 0.57.4

package/skills/configure-pi-sync/references/configuration.md

@@ -377,9 +377,9 @@ A verified accepted ancestor is required.
 Enabling Agent mode cannot recover historical ancestor bytes that were never retained.
 If the original accepted bytes are still available on both sides, a conflict-free sync can seed the text ancestors for future runs; otherwise use the existing reviewed recovery flow rather than inventing a base from current edits.
 
-Bounds are 8 KiB per input file, 16 conflict paths/units, 24 KiB of serialized model evidence, 16 KiB of candidate output, 8,192 maximum output tokens (or the selected model's smaller positive output limit), and one provider request per candidate.
+Bounds are 8 KiB per input file, 16 conflict paths/units, 24 KiB of serialized model evidence, 16 KiB of candidate output, 8,192 maximum output tokens (or the selected model's smaller positive output limit), and one provider request per candidate attempt. A separately confirmed refusal retry can request the same candidate evidence again.
 An unknown model limit of zero retains the resolver cap; invalid limits pause before disclosure.
-Each resolver has a 20-second deadline; the existing overall startup deadline is 30 seconds.
+Each resolver has a 20-second deadline that also cancels its validation and reservation prerequisites where cancellation is supported; the existing overall startup deadline is 30 seconds. Cleanup drains owned work and can take additional time. An atomic reservation or file replacement cannot be undone after publication.
 At most two candidate requests are made during one triggered flow when remote commit competition changes the plan.
 Provider retries are disabled.
 Invalid output, detected stale evidence, missing model/auth, or recovery uncertainty pauses the flow rather than forcing acceptance.
@@ -404,6 +404,16 @@ Private claim and content-keyed candidate records reside under `<state-root>/age
 Candidates can be reused only for matching evidence, policies and model identity, and are validated again.
 They can contain merged text; retain them as private data.
 Different candidates are retained without automatic retention pruning.
+Ordinary **Sync now** and `/sync sync` reuse a valid cached refusal without another provider request.
+The manager's **Retry refused model result…** action separately reviews the setup, destination, conflict paths, selected model, disclosure and cost before one fresh request for that exact refusal.
+It requires foreground TUI/RPC, Agent mode, an accepted baseline and no pending journal; use ordinary Sync now or reviewed recovery first when those prerequisites are absent.
+Changed evidence, settings, model, session or cached bytes invalidate the review without disclosure.
+A repeated refusal, invalid response or failed pre-publication replacement retains the original result.
+A complete validated result replaces the active candidate only after the original refusal is archived privately in the same directory.
+These archives use the existing candidate format and remain retained; no settings or accounting format migration is added.
+Cancellation cannot undo an already committed replacement or provider request.
+The action does not reset automatic accounting and never runs from background polling; no new textual command or flag is provided.
+When partial sync is off, known unsupported groups stop before inference rather than paying for a result that cannot complete the transfer.
 Duplicate provider billing remains possible at crash boundaries.
 Corrupt or unsafe records block reuse rather than being overwritten blindly.
 
@@ -472,7 +482,7 @@ Cycles do not overlap.
 Each cycle has a 30-second deadline plus underlying cleanup.
 Changes during a cycle coalesce into one later fresh inspection rather than a queue of stale commands.
 
-Known transient network/server errors and rate limits retry from five seconds with exponential backoff, bounded jitter and a five-minute cap.
+Known transient network/server errors, rate limits and proven pre-publication local/baseline/remote freshness races retry from five seconds with exponential backoff, bounded jitter and a five-minute cap.
 Valid server Retry-After delays are capped at five minutes.
 Backoff survives restart and is reset by successful work or relevant configuration changes, not every file event.
 
@@ -505,8 +515,9 @@ Automatic requests are limited to:
 A refusal or invalid output blocks unchanged evidence rather than requesting another completion each poll.
 When the rolling window is full, Status shows the next eligible attempt.
 Checks, conflict-free transfers and journal recovery can continue without another model request.
-When the candidate's two attempts are spent, use changed evidence or an explicit retry.
-The explicit **Sync now** / `/sync sync` path retains its existing per-flow limits; it does not erase automatic accounting.
+When the candidate's two automatic attempts are spent, waiting does not restore them.
+The explicit **Sync now** / `/sync sync` path retains its existing per-flow limits; it does not erase automatic accounting and continues to reuse cached refusals.
+Use changed evidence, the separately confirmed **Retry refused model result…** action for a current cached refusal, or an existing reviewed recovery route as appropriate.
 Opening Status never reserves requests or clears limits.
 
 These limits are not a currency spending cap or an exactly-once billing guarantee.
@@ -523,6 +534,11 @@ Keep the directory as private evidence; do not delete it to repair a transfer.
 
 The existing status key shows waiting, checking/syncing, scheduled retry, another local owner, or a stable blocked reason.
 **Check remote status** and the manager show advisory ownership, the last successful background check/transfer and safe next actions.
+Status also shows normalized rolling-window usage, the next window allowance, exhausted-candidate counts, serialized accounting bytes/capacity and on-disk bytes.
+Window allowance is not dispatch permission: candidate, capacity, ownership and safety checks still apply.
+Status normalization affects only the detached read; it does not expire durable calls, reserve requests, create private directories or reset limits.
+The scheduler owner's model is reported as unavailable rather than inferred from the observing session.
+A full or unverifiable record is not unused allowance; retain it and use reviewed repair instead of deleting accounting.
 Notifications are deduplicated by error/evidence/configuration.
 Status may itself need network access for its existing remote check, but does not call the model.
 

package/src/commands/command-execution.ts

@@ -74,6 +74,7 @@ export async function executeCommand(
   onCommit?: () => void,
   setup?: string,
   onDialog?: (active: boolean) => void,
+  retryRefusal = false,
 ): Promise<RunRouteResult> {
   ctx = trackOperationDialogs(ctx, onDialog);
   try {
@@ -85,6 +86,10 @@ export async function executeCommand(
     if (signal) options.signal = signal;
     if (onCommit) options.onCommit = onCommit;
     validateCommandOptions(subcommand, options);
+    if (retryRefusal) {
+      if (subcommand !== "sync") throw new Error("A refused-model retry is available only for merged sync.");
+      options.agentRetryRefusal = true;
+    }
 
     switch (subcommand) {
       case "help":
@@ -157,8 +162,8 @@ export async function executeCommand(
       case "sync": {
         const operations = await loaders.operations();
         throwIfAborted(options.signal);
-        await withAgentSyncLock(ctx, options, (current) => operations.syncBoth(ctx, current));
-        return { kind: "completed" };
+        const outcome = await withAgentSyncLock(ctx, options, (current) => operations.syncBoth(ctx, current));
+        return { kind: "completed", ...(retryRefusal && outcome ? { outcome } : {}) };
       }
       case "history": {
         const operations = await loaders.operations();

package/src/commands/command-handler.ts

@@ -32,9 +32,10 @@ export async function handleCommand(
     onCommit?: () => void,
     target?: string,
     onDialog?: (active: boolean) => void,
+    retryRefusal = false,
   ) => {
     const [command, ...args] = splitArgs(route);
-    if (command === "sync") {
+    if (command === "sync" && !retryRefusal) {
       try {
         const options = parseOptions(args);
         validateCommandOptions("sync", options);
@@ -51,6 +52,7 @@ export async function handleCommand(
       observationCommitCallback(attention, sessionSignal, onCommit),
       target,
       onDialog,
+      retryRefusal,
     );
   };
   if (!rawArgs.trim()) {

package/src/commands/command-types.ts

@@ -17,7 +17,9 @@ export interface CommandOptions {
   /** Internal validated resolver result; never parsed from command arguments. */
   agentAcceptance?: AgentAcceptance;
   /** Internal cycle authorization, ownership and durable request reservation; never command arguments. */
-  background?: { validate(config?: AnySyncConfig): void; reserve(key: string): Promise<void> };
+  background?: { validate(config?: AnySyncConfig): void; reserve(key: string, signal?: AbortSignal): Promise<void> };
+  /** Manager-only, separately confirmed retry; never parsed from command arguments. */
+  agentRetryRefusal?: boolean;
   args: string[];
 }
 

package/src/sync/agent-plan.ts

@@ -28,7 +28,11 @@ export async function resolveAgentPlan(
   snapshotOptions: SnapshotOptions,
   validate: () => Promise<void>,
 ): Promise<FileMergePlan> {
-  if (plan.kind !== "planned" || !plan.conflicts.length) return plan;
+  if (plan.kind !== "planned" || !plan.conflicts.length) {
+    if (options.agentRetryRefusal)
+      throw new ContinuousError("unsafe", "No eligible cached refusal for the current evidence. Use Sync now.");
+    return plan;
+  }
   if (!ctx.hasUI || (ctx.mode !== "tui" && ctx.mode !== "rpc"))
     throw new Error("Agent mode paused: TUI/RPC is required.");
   const ancestors = (await readMergeAncestors(config, state)) ?? [];
@@ -39,14 +43,22 @@ export async function resolveAgentPlan(
   } catch {
     throw new ContinuousError("unsafe", "Agent mode paused: unsafe or unsupported conflict evidence.");
   }
+  if (!config.partialSync && evidence.unsupported.length)
+    throw new ContinuousError("unsafe", "Agent mode paused: unsupported conflicts prevent an all-or-nothing transfer.");
   if (!evidence.files.length) {
+    if (options.agentRetryRefusal)
+      throw new ContinuousError("unsafe", "No eligible cached refusal for the current evidence. Use Sync now.");
     if (config.partialSync) return plan;
     throw new ContinuousError(
       "unsafe",
       "Agent mode paused: unsupported conflict or missing verified ancestor; evidence is unchanged.",
     );
   }
-  if (!evidence.units.length) return applyAgentCandidate(plan, evidence, { version: 1, results: [] });
+  if (!evidence.units.length) {
+    if (options.agentRetryRefusal)
+      throw new ContinuousError("unsafe", "No eligible cached refusal for the current evidence. Use Sync now.");
+    return applyAgentCandidate(plan, evidence, { version: 1, results: [] });
+  }
   if (!ctx.model) throw new ContinuousError("model", "Agent mode paused: select an available model first.");
   const model = digest(ctx.model);
   const key = digest([
@@ -66,15 +78,20 @@ export async function resolveAgentPlan(
       throw new ContinuousError("unsafe", "Agent mode paused: candidate refused or unsupported conflict remains.");
     }
   }
-  const validateEvidence = async () => {
-    await validate();
+  const validateEvidence = async (signal = options.signal) => {
+    const check = async () => {
+      signal?.throwIfAborted();
+      await validate();
+      signal?.throwIfAborted();
+    };
+    await check();
     if (digest(ctx.model) !== model) throw new Error("Agent mode paused: selected model changed.");
-    const current = await createSnapshot(config.snapshotIdentity, snapshotOptions);
-    await validate();
+    const current = await createSnapshot(config.snapshotIdentity, { ...snapshotOptions, signal });
+    await check();
     const currentState = await readStateForConfig(config);
-    await validate();
-    const currentHead = await backend.readHead(options.signal);
-    await validate();
+    await check();
+    const currentHead = await backend.readHead(signal);
+    await check();
     if (
       !sameHashes(fileHashMap(current), fileHashMap(localRaw)) ||
       syncStateFingerprint(currentState) !== syncStateFingerprint(state) ||

package/src/sync/agent-refusal-retry.ts

@@ -0,0 +1,54 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { loadConfig } from "../settings/config.js";
+import { confirmMergeReview } from "../ui/merge-review.js";
+import { safeTerminalText } from "../ui/terminal-text.js";
+import type { AgentEvidence } from "./agent-candidate.js";
+import { captureMutationOwner } from "./sync-local.js";
+
+/** Review uses fresh request validation; no private text or provider error enters the summary. */
+export async function confirmAgentRefusalRetry(
+  ctx: ExtensionContext,
+  setup: string | undefined,
+  evidence: AgentEvidence,
+  validate: () => Promise<void>,
+  signal?: AbortSignal,
+) {
+  const owner = captureMutationOwner(ctx, signal);
+  owner();
+  const config = await loadConfig(setup);
+  owner();
+  await validate();
+  owner();
+  const summary = [
+    `Setup: ${safeTerminalText(config.setupName)}`,
+    `Storage connection: ${safeTerminalText(config.connectionName)}`,
+    `Storage path: ${safeTerminalText(config.storagePath)}`,
+    ...(config.backend.type === "s3" ? [`Bucket: ${safeTerminalText(config.backend.destination.bucket)}`] : []),
+    ...(config.backend.type === "git" ? [`Branch: ${safeTerminalText(config.backend.destination.branch)}`] : []),
+    `Selected model: ${safeTerminalText(ctx.model?.provider ?? "unknown")}/${safeTerminalText(ctx.model?.id ?? "unknown")}`,
+    `Conflict paths: ${[...new Set(evidence.units.map((unit) => unit.path))].map(safeTerminalText).join(", ")}`,
+    "Send this conflict evidence again despite the cached refusal? This permits one fresh provider request for the reviewed candidate, may incur costs, and can replace selected local and remote content if the result passes validation. Semantic correctness is not guaranteed.",
+    "Ordinary Sync now continues to reuse cached results. Automatic request accounting is not cleared or reset. The previous refusal is retained privately. No resources reload automatically. Cancellation cannot recall submitted content, provider charges, or committed writes.",
+  ].join("\n\n");
+  const confirmed = await confirmMergeReview(
+    ctx,
+    "Retry refused model result?",
+    summary,
+    signal,
+    () => {
+      try {
+        owner();
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    "Send one fresh request",
+    summary.split("\n"),
+  );
+  owner();
+  if (!confirmed) return false;
+  await validate();
+  owner();
+  return true;
+}

package/src/sync/agent-request.ts

@@ -3,13 +3,15 @@ import type { AgentCandidate, AgentEvidence } from "./agent-candidate.js";
 export interface AgentAcceptance {
   key: string;
   candidate: AgentCandidate;
+  /** Retry-only cache publication after the full merge/application preflight passes. */
+  commitCandidate?: () => Promise<void>;
 }
 /** Internal control flow: the operation lock must unwind before any provider call. */
 export class AgentResolutionRequired extends Error {
   constructor(
     readonly key: string,
     readonly evidence: AgentEvidence,
-    readonly validate: () => Promise<void>,
+    readonly validate: (signal?: AbortSignal) => Promise<void>,
   ) {
     super("Agent resolution requires an unlocked inference phase.");
     this.name = "AgentResolutionRequired";

package/src/sync/agent-runner.ts

@@ -34,9 +34,9 @@ export function resolverResources(): ResourceLoader {
 export async function runAgentResolver(
   ctx: ExtensionContext,
   evidence: AgentEvidence,
-  validate: () => Promise<void>,
+  validate: (signal: AbortSignal) => Promise<void>,
   signal?: AbortSignal,
-  beforeRequest?: () => Promise<void>,
+  beforeRequest?: (signal: AbortSignal) => Promise<void>,
 ): Promise<string> {
   const model = ctx.model;
   if (!model) throw new ContinuousError("model", "Agent mode paused: select an available model first.");
@@ -105,12 +105,13 @@ export async function runAgentResolver(
     child.agent.streamFunction = async (_model, context, options) => {
       ownedSignal.throwIfAborted();
       if (++calls > 1) throw new Error("Agent mode paused: one provider request per candidate is permitted.");
-      await validate();
+      await validate(ownedSignal);
       ownedSignal.throwIfAborted();
       if (beforeRequest) {
         try {
-          await beforeRequest();
-          await validate();
+          await beforeRequest(ownedSignal);
+          ownedSignal.throwIfAborted();
+          await validate(ownedSignal);
           ownedSignal.throwIfAborted();
         } catch (error) {
           transportFailure = error;
@@ -137,7 +138,8 @@ export async function runAgentResolver(
       ownedSignal.throwIfAborted();
       await child.prompt(JSON.stringify({ units: evidence.units }));
       ownedSignal.throwIfAborted();
-      await validate();
+      await validate(ownedSignal);
+      ownedSignal.throwIfAborted();
       const last = child.messages.at(-1);
       if (
         last?.role !== "assistant" ||

package/src/sync/agent-store.ts

@@ -1,4 +1,4 @@
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path";
 import lockfile from "proper-lockfile";
@@ -7,6 +7,7 @@ import { withLock } from "../state/lock.js";
 import { LOCK_GUARD_STALE_MS, LOCK_GUARD_UPDATE_MS } from "../state/lock-policy.js";
 import { LOCKFILE_FS_ADAPTER } from "../state/lockfile-fs.js";
 import { stateDir } from "../state/state-directory.js";
+import type { AgentCandidate } from "./agent-candidate.js";
 import { AGENT_OUTPUT_BYTES } from "./agent-policy.js";
 import { ContinuousError } from "./continuous-errors.js";
 
@@ -149,3 +150,33 @@ export async function saveAgentCandidate(key: string, candidate: unknown) {
   }
   await writeJson(target, candidate, { maxBytes: AGENT_OUTPUT_BYTES * 2 });
 }
+
+/** Caller holds the resolver claim and operation lock and has validated both candidates. */
+export async function replaceRefusedAgentCandidate(
+  key: string,
+  previous: AgentCandidate,
+  candidate: AgentCandidate,
+  validate: () => Promise<void>,
+) {
+  const original = JSON.stringify(previous);
+  if (!previous.results.some((row) => "refuse" in row) || candidate.results.some((row) => "refuse" in row))
+    throw new Error("Only a validated refusal can be replaced by a complete retry result.");
+  const target = candidatePath(key);
+  const assertPrevious = async () => {
+    if (JSON.stringify(await readPrivate(target)) !== original)
+      throw new Error("Cached refusal changed during review; previous evidence retained.");
+    await validate();
+  };
+  await assertPrevious();
+  const digest = createHash("sha256").update(original).digest("hex");
+  const archive = path.join(paths().root, `${key}.refusal-${digest}.json`);
+  const retained = await readPrivate(archive);
+  await validate();
+  if (retained !== undefined && JSON.stringify(retained) !== original)
+    throw new Error("Retained refusal changed; evidence retained.");
+  if (retained === undefined) await writeJson(archive, previous, { maxBytes: AGENT_OUTPUT_BYTES * 2 });
+  await assertPrevious();
+  // Archive first: even a durability error after replacement retains the original refusal.
+  // Once rename commits, later cancellation cannot undo the valid new candidate.
+  await writeJson(target, candidate, { maxBytes: AGENT_OUTPUT_BYTES * 2 });
+}

package/src/sync/agent-sync.ts

@@ -11,16 +11,21 @@ export async function withAgentSyncLock<T>(
   ctx: ExtensionContext,
   options: CommandOptions,
   run: (options: CommandOptions) => Promise<T>,
-): Promise<T> {
+): Promise<T | "cancelled"> {
   let request: AgentResolutionRequired;
   const background = options.background;
+  const retry = Boolean(options.agentRetryRefusal);
+  if (retry && (options.auto || background || !ctx.hasUI || (ctx.mode !== "tui" && ctx.mode !== "rpc")))
+    throw new Error("A refused-model retry requires a foreground TUI or RPC manager review.");
   try {
     return await withLock("sync", () => run(options));
   } catch (error) {
     if (!(error instanceof AgentResolutionRequired)) throw error;
     request = error;
   }
-  const { withAgentClaim, readAgentCandidate, saveAgentCandidate } = await import("./agent-store.js");
+  const { withAgentClaim, readAgentCandidate, saveAgentCandidate, replaceRefusedAgentCandidate } = await import(
+    "./agent-store.js"
+  );
   const { parseAgentCandidate } = await import("./agent-candidate.js");
   const { runAgentResolver } = await import("./agent-runner.js");
   return withAgentClaim(async (assertOwner) => {
@@ -36,27 +41,48 @@ export async function withAgentSyncLock<T>(
     try {
       options.signal?.throwIfAborted();
       for (let attempt = 0; attempt < AGENT_MAX_ATTEMPTS; attempt++) {
-        const validate = () =>
+        let expectedRefusal: ReturnType<typeof parseAgentCandidate> | undefined;
+        const validate = (signal = options.signal) =>
           withLock("agent-validate", async () => {
-            options.signal?.throwIfAborted();
+            signal?.throwIfAborted();
             await assertOwner();
-            await request.validate();
-            options.signal?.throwIfAborted();
+            signal?.throwIfAborted();
+            if (
+              expectedRefusal &&
+              JSON.stringify(await readAgentCandidate(request.key)) !== JSON.stringify(expectedRefusal)
+            )
+              throw new Error("Cached refusal changed during review; reopen the manager.");
+            signal?.throwIfAborted();
+            await request.validate(signal);
+            signal?.throwIfAborted();
           });
         await validate();
         setSyncStatus(ctx, "sync resolving");
         const cached = await withLock("agent-cache-read", async () => {
           await assertOwner();
+          options.signal?.throwIfAborted();
           return readAgentCandidate(request.key);
         });
+        options.signal?.throwIfAborted();
+        if (retry) {
+          if (cached === undefined)
+            throw new Error("No eligible cached refusal for the current evidence. Use Sync now first.");
+          expectedRefusal = parseAgentCandidate(JSON.stringify(cached), request.evidence);
+          if (!expectedRefusal.results.some((row) => "refuse" in row))
+            throw new Error("The current cached result is not a refusal. Use Sync now.");
+          const { confirmAgentRefusalRetry } = await import("./agent-refusal-retry.js");
+          options.signal?.throwIfAborted();
+          if (!(await confirmAgentRefusalRetry(ctx, options.setup, request.evidence, validate, options.signal)))
+            return "cancelled" as const;
+        }
         const raw =
-          cached === undefined
+          cached === undefined || retry
             ? await runAgentResolver(
                 ctx,
                 request.evidence,
                 validate,
                 options.signal,
-                background ? () => background.reserve(request.key) : undefined,
+                background ? (signal) => background.reserve(request.key, signal) : undefined,
               )
             : JSON.stringify(cached);
         let candidate: ReturnType<typeof parseAgentCandidate>;
@@ -65,12 +91,35 @@ export async function withAgentSyncLock<T>(
         } catch {
           throw new ContinuousError("model", "Agent mode paused: invalid resolver output; evidence retained.");
         }
+        if (retry && candidate.results.some((row) => "refuse" in row))
+          throw new ContinuousError("model", "The model refused again. The previous refusal was retained.");
         await validate();
-        await withLock("agent-cache-save", async () => {
-          await assertOwner();
-          await saveAgentCandidate(request.key, candidate);
-        });
-        const acceptance: AgentAcceptance = { key: request.key, candidate };
+        const previous = expectedRefusal;
+        if (!previous)
+          await withLock("agent-cache-save", async () => {
+            await assertOwner();
+            options.signal?.throwIfAborted();
+            await saveAgentCandidate(request.key, candidate);
+          });
+        let retryCacheCommitted = false;
+        const acceptance: AgentAcceptance = {
+          key: request.key,
+          candidate,
+          ...(previous
+            ? {
+                commitCandidate: async () => {
+                  if (retryCacheCommitted) return;
+                  await replaceRefusedAgentCandidate(request.key, previous, candidate, async () => {
+                    options.signal?.throwIfAborted();
+                    await assertOwner();
+                    await request.validate(options.signal);
+                    options.signal?.throwIfAborted();
+                  });
+                  retryCacheCommitted = true;
+                },
+              }
+            : {}),
+        };
         try {
           return await withLock("sync", async () => {
             await assertOwner();
@@ -79,6 +128,7 @@ export async function withAgentSyncLock<T>(
           });
         } catch (error) {
           if (!(error instanceof AgentResolutionRequired)) throw error;
+          if (retry) throw new ContinuousError("stale", "Reviewed refusal evidence changed; reopen the manager.");
           request = error;
         }
       }

package/src/sync/continuous-lease.ts

@@ -49,13 +49,8 @@ export async function continuousLeaseOwner(binding: string): Promise<string> {
   if (!validOwner(owner)) throw new Error("Invalid continuous sync owner");
   try {
     const guard = await fs.lstat(path.join(continuousRoot(), "scheduler.lock"));
-    if (
-      guard.isDirectory() &&
-      !guard.isSymbolicLink() &&
-      Date.now() - guard.mtimeMs <= STALE_MS &&
-      owner.binding === binding
-    )
-      return `Local scheduler lease: observed for pid ${owner.pid}; this can be another session`;
+    if (guard.isDirectory() && !guard.isSymbolicLink() && Date.now() - guard.mtimeMs <= STALE_MS)
+      return `Local scheduler lease: observed for pid ${owner.pid}; ${owner.binding === binding ? "this can be another session" : "another setup; this setup is standby"}`;
   } catch (error) {
     if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
   }