@phuetz/code-buddy 1.1.0 → 1.3.0

package/dist/utils/config-validation/schema.d.ts

@@ -47,7 +47,7 @@ export interface ValidationResult {
 /**
  * Valid AI provider options
  */
-export declare const AI_PROVIDERS: readonly ["grok", "claude", "openai", "gemini", "ollama", "lmstudio", "local"];
+export declare const AI_PROVIDERS: readonly ["grok", "xai", "claude", "anthropic", "openai", "chatgpt", "gemini", "google", "ollama", "ollama-cloud", "lmstudio", "lm-studio", "local", "mistral", "groq", "together", "fireworks", "openrouter", "novita", "novita-ai", "zai", "glm", "kimi-coding", "kimi", "moonshot", "kimi-coding-cn", "kimi-cn", "moonshot-cn", "arcee", "arcee-ai", "gmi", "gmi-cloud", "gmicloud", "minimax", "minimax-cn", "alibaba", "qwen", "dashscope", "alibaba-coding-plan", "alibaba-coding", "kilocode", "kilo-code", "xiaomi", "mimo", "tencent-tokenhub", "tencent", "tokenhub", "opencode-zen", "opencode", "opencode-go", "deepseek", "huggingface", "hf", "nvidia", "nvidia-nim", "stepfun", "vllm", "custom"];
 export type AIProvider = typeof AI_PROVIDERS[number];
 /**
  * Valid autonomy levels
@@ -82,6 +82,25 @@ export declare const SettingsSchema: z.ZodObject<{
     enableCheckpoints: z.ZodDefault<z.ZodBoolean>;
     enableTelemetry: z.ZodDefault<z.ZodBoolean>;
     thinkingLevel: z.ZodOptional<z.ZodEnum<["off", "minimal", "low", "medium", "high"]>>;
+    goals: z.ZodOptional<z.ZodObject<{
+        maxTurns: z.ZodOptional<z.ZodNumber>;
+        judgeModel: z.ZodOptional<z.ZodString>;
+        plannerModel: z.ZodOptional<z.ZodString>;
+        judgeMaxTokens: z.ZodOptional<z.ZodNumber>;
+        judgeTimeoutMs: z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        maxTurns?: number | undefined;
+        judgeModel?: string | undefined;
+        plannerModel?: string | undefined;
+        judgeMaxTokens?: number | undefined;
+        judgeTimeoutMs?: number | undefined;
+    }, {
+        maxTurns?: number | undefined;
+        judgeModel?: string | undefined;
+        plannerModel?: string | undefined;
+        judgeMaxTokens?: number | undefined;
+        judgeTimeoutMs?: number | undefined;
+    }>>;
     turboquant: z.ZodOptional<z.ZodObject<{
         vllmEndpoint: z.ZodOptional<z.ZodString>;
         ollamaEndpoint: z.ZodOptional<z.ZodString>;
@@ -166,6 +185,13 @@ export declare const SettingsSchema: z.ZodObject<{
     maxTokens?: number | undefined;
     agentMode?: "code" | "plan" | "ask" | "architect" | undefined;
     contextWindow?: number | undefined;
+    goals?: {
+        maxTurns?: number | undefined;
+        judgeModel?: string | undefined;
+        plannerModel?: string | undefined;
+        judgeMaxTokens?: number | undefined;
+        judgeTimeoutMs?: number | undefined;
+    } | undefined;
     turboquant?: {
         vllmEndpoint?: string | undefined;
         ollamaEndpoint?: string | undefined;
@@ -196,6 +222,13 @@ export declare const SettingsSchema: z.ZodObject<{
     contextWindow?: number | undefined;
     enableCheckpoints?: boolean | undefined;
     enableTelemetry?: boolean | undefined;
+    goals?: {
+        maxTurns?: number | undefined;
+        judgeModel?: string | undefined;
+        plannerModel?: string | undefined;
+        judgeMaxTokens?: number | undefined;
+        judgeTimeoutMs?: number | undefined;
+    } | undefined;
     turboquant?: {
         vllmEndpoint?: string | undefined;
         ollamaEndpoint?: string | undefined;
@@ -220,14 +253,14 @@ export declare const UserSettingsSchema: z.ZodObject<{
     baseURL: z.ZodOptional<z.ZodString>;
     defaultModel: z.ZodDefault<z.ZodString>;
     models: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
-    provider: z.ZodDefault<z.ZodEnum<["grok", "claude", "openai", "gemini", "ollama", "lmstudio", "local"]>>;
+    provider: z.ZodDefault<z.ZodEnum<["grok", "xai", "claude", "anthropic", "openai", "chatgpt", "gemini", "google", "ollama", "ollama-cloud", "lmstudio", "lm-studio", "local", "mistral", "groq", "together", "fireworks", "openrouter", "novita", "novita-ai", "zai", "glm", "kimi-coding", "kimi", "moonshot", "kimi-coding-cn", "kimi-cn", "moonshot-cn", "arcee", "arcee-ai", "gmi", "gmi-cloud", "gmicloud", "minimax", "minimax-cn", "alibaba", "qwen", "dashscope", "alibaba-coding-plan", "alibaba-coding", "kilocode", "kilo-code", "xiaomi", "mimo", "tencent-tokenhub", "tencent", "tokenhub", "opencode-zen", "opencode", "opencode-go", "deepseek", "huggingface", "hf", "nvidia", "nvidia-nim", "stepfun", "vllm", "custom"]>>;
     model: z.ZodOptional<z.ZodString>;
     theme: z.ZodDefault<z.ZodEnum<["dark", "light", "auto", "default", "neon", "pastel", "matrix", "ocean", "sunset", "minimal", "high-contrast"]>>;
     editor: z.ZodOptional<z.ZodString>;
     shell: z.ZodOptional<z.ZodString>;
     language: z.ZodDefault<z.ZodString>;
 }, "strict", z.ZodTypeAny, {
-    provider: "openai" | "lmstudio" | "ollama" | "gemini" | "grok" | "local" | "claude";
+    provider: "custom" | "xai" | "anthropic" | "google" | "openai" | "lmstudio" | "ollama" | "mistral" | "gemini" | "grok" | "lm-studio" | "local" | "minimax" | "moonshot" | "claude" | "deepseek" | "qwen" | "chatgpt" | "ollama-cloud" | "groq" | "together" | "fireworks" | "openrouter" | "novita" | "zai" | "kimi-coding" | "kimi-coding-cn" | "arcee" | "gmi" | "minimax-cn" | "alibaba" | "alibaba-coding-plan" | "kilocode" | "xiaomi" | "tencent-tokenhub" | "opencode-zen" | "opencode-go" | "huggingface" | "nvidia" | "stepfun" | "vllm" | "novita-ai" | "glm" | "kimi" | "kimi-cn" | "moonshot-cn" | "arcee-ai" | "gmi-cloud" | "gmicloud" | "dashscope" | "alibaba-coding" | "kilo-code" | "mimo" | "tencent" | "tokenhub" | "opencode" | "hf" | "nvidia-nim";
     models: string[];
     defaultModel: string;
     theme: "minimal" | "default" | "auto" | "dark" | "light" | "neon" | "pastel" | "matrix" | "ocean" | "sunset" | "high-contrast";
@@ -238,12 +271,12 @@ export declare const UserSettingsSchema: z.ZodObject<{
     apiKey?: string | undefined;
     editor?: string | undefined;
 }, {
-    provider?: "openai" | "lmstudio" | "ollama" | "gemini" | "grok" | "local" | "claude" | undefined;
+    provider?: "custom" | "xai" | "anthropic" | "google" | "openai" | "lmstudio" | "ollama" | "mistral" | "gemini" | "grok" | "lm-studio" | "local" | "minimax" | "moonshot" | "claude" | "deepseek" | "qwen" | "chatgpt" | "ollama-cloud" | "groq" | "together" | "fireworks" | "openrouter" | "novita" | "zai" | "kimi-coding" | "kimi-coding-cn" | "arcee" | "gmi" | "minimax-cn" | "alibaba" | "alibaba-coding-plan" | "kilocode" | "xiaomi" | "tencent-tokenhub" | "opencode-zen" | "opencode-go" | "huggingface" | "nvidia" | "stepfun" | "vllm" | "novita-ai" | "glm" | "kimi" | "kimi-cn" | "moonshot-cn" | "arcee-ai" | "gmi-cloud" | "gmicloud" | "dashscope" | "alibaba-coding" | "kilo-code" | "mimo" | "tencent" | "tokenhub" | "opencode" | "hf" | "nvidia-nim" | undefined;
     model?: string | undefined;
     shell?: string | undefined;
     models?: string[] | undefined;
-    baseURL?: string | undefined;
     defaultModel?: string | undefined;
+    baseURL?: string | undefined;
     apiKey?: string | undefined;
     theme?: "minimal" | "default" | "auto" | "dark" | "light" | "neon" | "pastel" | "matrix" | "ocean" | "sunset" | "high-contrast" | undefined;
     editor?: string | undefined;
@@ -452,9 +485,9 @@ export declare const EnvVarsSchema: z.ZodObject<{
     DEBUG?: boolean | undefined;
     LOG_LEVEL?: "debug" | "info" | "warn" | "error" | undefined;
     NO_COLOR?: string | undefined;
-    GROK_BASE_URL?: string | undefined;
     GROK_MODEL?: string | undefined;
     GROK_API_KEY?: string | undefined;
+    GROK_BASE_URL?: string | undefined;
     MORPH_API_KEY?: string | undefined;
     YOLO_MODE?: boolean | undefined;
     MAX_COST?: number | undefined;
@@ -464,9 +497,9 @@ export declare const EnvVarsSchema: z.ZodObject<{
     DEBUG?: "0" | "1" | "true" | "false" | undefined;
     LOG_LEVEL?: "debug" | "info" | "warn" | "error" | undefined;
     NO_COLOR?: string | undefined;
-    GROK_BASE_URL?: string | undefined;
     GROK_MODEL?: string | undefined;
     GROK_API_KEY?: string | undefined;
+    GROK_BASE_URL?: string | undefined;
     MORPH_API_KEY?: string | undefined;
     YOLO_MODE?: "0" | "1" | "true" | "false" | undefined;
     MAX_COST?: string | undefined;

package/dist/utils/config-validation/schema.js

@@ -11,7 +11,66 @@ import { z } from 'zod';
 /**
  * Valid AI provider options
  */
-export const AI_PROVIDERS = ['grok', 'claude', 'openai', 'gemini', 'ollama', 'lmstudio', 'local'];
+export const AI_PROVIDERS = [
+    'grok',
+    'xai',
+    'claude',
+    'anthropic',
+    'openai',
+    'chatgpt',
+    'gemini',
+    'google',
+    'ollama',
+    'ollama-cloud',
+    'lmstudio',
+    'lm-studio',
+    'local',
+    'mistral',
+    'groq',
+    'together',
+    'fireworks',
+    'openrouter',
+    'novita',
+    'novita-ai',
+    'zai',
+    'glm',
+    'kimi-coding',
+    'kimi',
+    'moonshot',
+    'kimi-coding-cn',
+    'kimi-cn',
+    'moonshot-cn',
+    'arcee',
+    'arcee-ai',
+    'gmi',
+    'gmi-cloud',
+    'gmicloud',
+    'minimax',
+    'minimax-cn',
+    'alibaba',
+    'qwen',
+    'dashscope',
+    'alibaba-coding-plan',
+    'alibaba-coding',
+    'kilocode',
+    'kilo-code',
+    'xiaomi',
+    'mimo',
+    'tencent-tokenhub',
+    'tencent',
+    'tokenhub',
+    'opencode-zen',
+    'opencode',
+    'opencode-go',
+    'deepseek',
+    'huggingface',
+    'hf',
+    'nvidia',
+    'nvidia-nim',
+    'stepfun',
+    'vllm',
+    'custom',
+];
 /**
  * Valid autonomy levels
  */
@@ -94,6 +153,39 @@ export const SettingsSchema = z.object({
     thinkingLevel: z.enum(['off', 'minimal', 'low', 'medium', 'high'])
         .optional()
         .describe('Gemini 3.x thinking/reasoning depth level'),
+    goals: z.object({
+        maxTurns: z.number()
+            .int('Must be an integer')
+            .min(1, 'Minimum 1 turn')
+            .max(1000, 'Maximum 1000 turns')
+            .optional()
+            .describe('Maximum continuation turns for persistent goals'),
+        judgeModel: z.string()
+            .trim()
+            .min(1, 'Judge model cannot be empty')
+            .max(100, 'Judge model name too long')
+            .optional()
+            .describe('Optional model override used to judge goal completion'),
+        plannerModel: z.string()
+            .trim()
+            .min(1, 'Planner model cannot be empty')
+            .max(100, 'Planner model name too long')
+            .optional()
+            .describe('Optional model override used to decompose complex goals'),
+        judgeMaxTokens: z.number()
+            .int('Must be an integer')
+            .min(1, 'Minimum 1 token')
+            .max(200000, 'Maximum 200000 tokens')
+            .optional()
+            .describe('Maximum output tokens for the goal judge'),
+        judgeTimeoutMs: z.number()
+            .int('Must be an integer')
+            .min(1000, 'Minimum 1000ms')
+            .max(600000, 'Maximum 600000ms')
+            .optional()
+            .describe('Timeout for goal judging requests'),
+    }).strict().optional()
+        .describe('Persistent goal continuation and judging settings'),
     turboquant: z.object({
         vllmEndpoint: z.string().url().optional()
             .describe('vLLM endpoint URL, e.g. http://192.168.1.50:8000'),
@@ -385,6 +477,43 @@ export const SCHEMAS = {
                 maximum: 200000,
                 description: 'Maximum tokens per request',
             },
+            goals: {
+                type: 'object',
+                description: 'Persistent goal continuation and judging settings',
+                properties: {
+                    maxTurns: {
+                        type: 'number',
+                        minimum: 1,
+                        maximum: 1000,
+                        description: 'Maximum continuation turns for persistent goals',
+                    },
+                    judgeModel: {
+                        type: 'string',
+                        minLength: 1,
+                        maxLength: 100,
+                        description: 'Optional model override used to judge goal completion',
+                    },
+                    plannerModel: {
+                        type: 'string',
+                        minLength: 1,
+                        maxLength: 100,
+                        description: 'Optional model override used to decompose complex goals',
+                    },
+                    judgeMaxTokens: {
+                        type: 'number',
+                        minimum: 1,
+                        maximum: 200000,
+                        description: 'Maximum output tokens for the goal judge',
+                    },
+                    judgeTimeoutMs: {
+                        type: 'number',
+                        minimum: 1000,
+                        maximum: 600000,
+                        description: 'Timeout for goal judging requests',
+                    },
+                },
+                additionalProperties: false,
+            },
         },
         additionalProperties: false,
     },

package/dist/utils/cost-tracker.js

@@ -25,6 +25,26 @@ function isChatGptSubscriptionModel(model) {
         m === 'codex-1' ||
         m.startsWith('codex-mini'));
 }
+function isLocalNoCostModel(model) {
+    if (!model)
+        return false;
+    const m = model.toLowerCase();
+    return (m === 'ollama' ||
+        m.startsWith('ollama/') ||
+        m === 'lmstudio' ||
+        m === 'local-model' ||
+        m.startsWith('llama') ||
+        m.startsWith('qwen') ||
+        m.startsWith('gemma') ||
+        m.startsWith('phi') ||
+        m.startsWith('codellama') ||
+        m.startsWith('deepseek') ||
+        m.startsWith('command-r') ||
+        m === 'mistral' ||
+        m.startsWith('mistral:') ||
+        m === 'mixtral' ||
+        m.startsWith('mixtral:'));
+}
 // Model pricing (approximate, update as needed)
 const MODEL_PRICING = {
     "grok-4-latest": { inputPer1k: 0.003, outputPer1k: 0.015 },
@@ -138,7 +158,7 @@ export class CostTracker extends EventEmitter {
      * misleading and shows up in dashboards as "spend" that doesn't exist.
      */
     calculateCost(inputTokens, outputTokens, model, cachedTokens = 0) {
-        if (isChatGptSubscriptionModel(model)) {
+        if (isChatGptSubscriptionModel(model) || isLocalNoCostModel(model)) {
             return 0;
         }
         const pricing = MODEL_PRICING[model] ?? MODEL_PRICING["default"] ?? { inputPer1k: 0.003, outputPer1k: 0.015 };

package/dist/utils/disk-guard.d.ts

@@ -0,0 +1,180 @@
+/**
+ * disk-guard — the single place that bounds disk access.
+ *
+ * Motivation: on 2026-06-17 a tight build/Electron restart loop leaked temp
+ * dirs until the disk filled mid-run, corrupting command-output capture
+ * (ENOSPC). The fix at the time guarded ONE call site (the Cowork pilot). This
+ * module generalizes that lesson into reusable primitives so the failure class
+ * — "unbounded resource accumulation in a tight loop without monitoring or
+ * cleanup" — is handled in one place:
+ *
+ *   - free-space preflight   → {@link getFreeSpaceInfo}, {@link ensureFreeSpace}
+ *   - managed temp lifecycle → {@link createManagedTempDir} (auto-cleaned on exit)
+ *   - orphan sweep backstop  → {@link sweepOrphans} (catches SIGKILL'd leaks)
+ *   - byte budget            → {@link DiskBudget}
+ *   - bounded writes / logs  → {@link boundedWriteFile}, {@link boundedAppendFile},
+ *                              {@link rotateIfLarge}
+ *
+ * Scope is deliberately focused. It is adopted at the highest-risk sites
+ * (disk-space checks, leaky /tmp dirs, unbounded append logs) rather than
+ * routing every fs write through it. It deliberately does NOT bound:
+ *   - general / user-intentional workspace writes (the user asked for them),
+ *   - third-party writers (Electron / Docker / Playwright) — covered instead by
+ *     the startup {@link sweepOrphans} backstop,
+ *   - low-traffic logs (add a one-line {@link rotateIfLarge} as needed).
+ *
+ * Config (read from the environment at call time, validated, with fallbacks —
+ * see {@link DISK_GUARD_DEFAULTS}; registered in `src/config/env-schema.ts`):
+ *   CODEBUDDY_MIN_FREE_MB, CODEBUDDY_DISK_QUOTA_MB, CODEBUDDY_TEMP_MAX_AGE_MS,
+ *   CODEBUDDY_LOG_MAX_MB, CODEBUDDY_LOG_MAX_FILES.
+ */
+import { CodeBuddyError } from '../errors/base-error.js';
+import { type Disposable } from './disposable.js';
+/** Built-in fallbacks, used when the matching env var is unset/invalid. */
+export declare const DISK_GUARD_DEFAULTS: {
+    /** Min free space (MB) before a guarded write/launch is refused. Matches the pilot's 500MB. */
+    readonly minFreeMb: 500;
+    /** Per-session byte budget (MB); 0 = unlimited. */
+    readonly quotaMb: 0;
+    /** Orphan-sweep age cutoff (ms); 0 = presence-based (remove any match). */
+    readonly tempMaxAgeMs: 0;
+    /** Append-log rotation size (MB). Matches logger.ts. */
+    readonly logMaxMb: 10;
+    /** Append-log retention count. Matches logger.ts. */
+    readonly logMaxFiles: 5;
+};
+/** Thrown by {@link ensureFreeSpace} when free disk space is below the threshold. */
+export declare class DiskSpaceError extends CodeBuddyError {
+    constructor(message: string, context: {
+        path: string;
+        freeBytes: number;
+        minBytes: number;
+    });
+}
+/** Thrown by {@link boundedWriteFile} when a {@link DiskBudget} reservation is refused. */
+export declare class DiskBudgetError extends CodeBuddyError {
+    constructor(message: string, context: {
+        usedBytes: number;
+        quotaBytes: number;
+        requestedBytes: number;
+    });
+}
+export interface FreeSpaceInfo {
+    freeBytes: number;
+    totalBytes: number;
+    freePercent: number;
+}
+/**
+ * Free-space info for the filesystem containing `targetPath`, or `null` when
+ * `fs.statfsSync` is unavailable / the path can't be stat'd (never throws).
+ * Uses `bavail` (blocks available to non-root) — the honest free figure a
+ * normal process can actually use — not `bfree`.
+ */
+export declare function getFreeSpaceInfo(targetPath: string): FreeSpaceInfo | null;
+/** Free bytes for the filesystem containing `targetPath`, or `null` if unavailable. */
+export declare function getFreeBytes(targetPath: string): number | null;
+/**
+ * Throw {@link DiskSpaceError} if free space on `targetPath`'s filesystem is
+ * below `minBytes` (default {@link DISK_GUARD_DEFAULTS.minFreeMb}). No-op when
+ * statfs is unavailable — we can't guard, so we don't block (matches the
+ * platform-resilient behavior of the original pilot guard).
+ */
+export declare function ensureFreeSpace(targetPath: string, minBytes?: number, opts?: {
+    label?: string;
+}): void;
+export interface SweepResult {
+    removed: string[];
+    skipped: string[];
+}
+/**
+ * Remove orphaned entries named `<prefix>*` directly under `root`. This is the
+ * durable backstop for the leak class: managed temp dirs are auto-disposed on a
+ * graceful exit, but a SIGKILL'd / crashed run skips cleanup and leaks its dir
+ * until the next startup sweep.
+ *
+ * - `maxAgeMs: 0` (default) → presence-based: remove every match (the original
+ *   pilot semantics — safe when only one instance runs at a time).
+ * - `maxAgeMs > 0` → age-safe: only remove matches whose mtime is older than
+ *   `maxAgeMs`, so a concurrently-running peer's fresh dir is never nuked.
+ */
+export declare function sweepOrphans(root: string, prefix: string, opts?: {
+    maxAgeMs?: number;
+    dryRun?: boolean;
+}): SweepResult;
+/**
+ * One-shot startup janitor: remove our own stale scratch dirs/files left in the
+ * system temp dir by crashed or SIGKILL'd runs (the durable backstop for the
+ * leak class). Age-gated (default 24h) so a concurrently-running session's fresh
+ * scratch dirs are never touched. Matches both `codebuddy-*` and `codebuddy_*`.
+ * Never throws.
+ */
+export declare function sweepStaleCodebuddyTemp(maxAgeMs?: number): SweepResult;
+export interface ManagedTempDir extends Disposable {
+    /** Absolute path of the created temp directory. */
+    readonly path: string;
+    /** Remove the directory and untrack it. Idempotent. */
+    dispose(): Promise<void>;
+}
+/** Dispose every still-tracked managed temp dir (invoked on graceful shutdown). */
+export declare function disposeAllManagedTempDirs(): Promise<void>;
+/**
+ * Create a temp directory that is tracked and auto-removed on graceful exit
+ * (and via the {@link Disposable} registry). Preflights {@link ensureFreeSpace}
+ * on the parent so we fail fast instead of mkdtemp'ing into a full disk.
+ *
+ * Pair this with a startup {@link sweepOrphans} on the same `parentDir`/`prefix`
+ * as the durable backstop for crashed runs that never reach `dispose()`.
+ */
+export declare function createManagedTempDir(prefix: string, opts?: {
+    parentDir?: string;
+    minFreeBytes?: number;
+}): Promise<ManagedTempDir>;
+export interface BudgetReservation {
+    allowed: boolean;
+    reason?: string;
+}
+/**
+ * Tracks cumulative bytes written against a quota
+ * (default {@link DISK_GUARD_DEFAULTS.quotaMb} → `CODEBUDDY_DISK_QUOTA_MB`).
+ * A quota of 0 means unlimited — every reservation is allowed.
+ */
+export declare class DiskBudget {
+    private readonly quotaBytes;
+    private usedBytes;
+    constructor(quotaBytes?: number);
+    /** Check (without recording) whether `bytes` more would fit. */
+    reserve(bytes: number): BudgetReservation;
+    record(bytes: number): void;
+    release(bytes: number): void;
+    used(): number;
+    remaining(): number;
+}
+/**
+ * Rotate `filePath` when it reaches `maxBytes`, keeping at most `maxFiles`
+ * generations (`name.1.ext` … `name.N.ext`, oldest dropped). Ports the
+ * algorithm in logger.ts so unbounded append logs can't fill the disk.
+ * Returns true if a rotation happened. Never throws.
+ */
+export declare function rotateIfLarge(filePath: string, maxBytes?: number, maxFiles?: number): boolean;
+/**
+ * Write a file after preflighting free space (and, if a {@link DiskBudget} is
+ * supplied, reserving + recording its size). Throws {@link DiskSpaceError} or
+ * {@link DiskBudgetError} before touching disk when bounds would be breached.
+ */
+export declare function boundedWriteFile(filePath: string, data: string | Uint8Array, opts?: {
+    minFreeBytes?: number;
+    budget?: DiskBudget;
+}): Promise<void>;
+/**
+ * Append to a file after optionally rotating it ({@link rotateIfLarge}) and
+ * preflighting free space. The append-log counterpart to {@link boundedWriteFile}.
+ */
+export declare function boundedAppendFile(filePath: string, data: string | Uint8Array, opts?: {
+    minFreeBytes?: number;
+    rotate?: {
+        maxBytes?: number;
+        maxFiles?: number;
+    };
+}): Promise<void>;
+/** Test helper: clear tracked temp dirs + reset the lazy shutdown-handler flag. */
+export declare function resetDiskGuardForTests(): void;