omp-fabric 1.11.0 → 1.13.0

package/dist/chunks/{chunk-Z7HQ6FYW.js → chunk-ANAXFBUE.js}

@@ -2,8 +2,9 @@ import {
   DEFAULT_FABRIC_THINKING,
   defaultCodePreviewSettings,
   isFabricThinking,
-  normalizeCodePreviewSettings
-} from "./chunk-JSBTB3P6.js";
+  normalizeCodePreviewSettings,
+  truncateMiddle
+} from "./chunk-SKYNDRW5.js";
 import {
   renameAtomic
 } from "./chunk-KAD7UWT2.js";
@@ -206,7 +207,7 @@ var resolveAvailableOmpModel = (selector, options) => {
 // src/config.ts
 import fs from "node:fs";
 import os from "node:os";
-import path from "node:path";
+import path2 from "node:path";
 
 // src/config-migrations.ts
 var CURRENT_FABRIC_CONFIG_VERSION = 5;
@@ -347,6 +348,175 @@ var migrateFabricConfigDocument = (input) => {
   };
 };
 
+// src/output-budget.ts
+import { mkdir, readdir, rm, stat, writeFile } from "node:fs/promises";
+import { randomBytes } from "node:crypto";
+import path from "node:path";
+var MAX_FAILURE_MODEL_OUTPUT_CHARS = 2e4;
+var modelOutputBudget = (configuredMaxChars, success) => success ? configuredMaxChars : Math.min(configuredMaxChars, MAX_FAILURE_MODEL_OUTPUT_CHARS);
+var fabricStateDir = (env = process.env) => path.join(
+  env.XDG_STATE_HOME || path.join(env.HOME || ".", ".local", "state"),
+  "omp-fabric"
+);
+var outputArtifactDir = (env = process.env) => path.join(fabricStateDir(env), "output");
+var DEFAULT_OUTPUT_ARTIFACT_RETENTION = {
+  maxAgeMs: 7 * 24 * 60 * 60 * 1e3,
+  maxBytes: 256 * 1024 * 1024
+};
+var OUTPUT_ARTIFACT_SWEEP_INTERVAL_MS = 5 * 60 * 1e3;
+var sweptAt;
+var lastSweep;
+var resetOutputArtifactSweepSchedule = () => {
+  sweptAt = void 0;
+  lastSweep = void 0;
+};
+var activeRetention = DEFAULT_OUTPUT_ARTIFACT_RETENTION;
+var configureOutputArtifactRetention = (retention) => {
+  const changed = retention.maxAgeMs !== activeRetention.maxAgeMs || retention.maxBytes !== activeRetention.maxBytes;
+  activeRetention = { maxAgeMs: retention.maxAgeMs, maxBytes: retention.maxBytes };
+  if (changed) resetOutputArtifactSweepSchedule();
+};
+var ARTIFACT_FILE = /^output-[0-9a-z]+-(?:p([0-9a-z]+)-)?[0-9a-f]+\.txt$/;
+var ownerAlive = (pid) => {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return !(error instanceof Error && "code" in error && error.code === "ESRCH");
+  }
+};
+var sweepOutputArtifacts = async (options = {}) => {
+  const directory = options.directory ?? outputArtifactDir();
+  const retention = options.retention ?? activeRetention;
+  const now = options.now ?? Date.now();
+  const alive = options.isOwnerAlive ?? ownerAlive;
+  let names;
+  try {
+    names = await readdir(directory);
+  } catch {
+    return { removed: [], keptBytes: 0, heldBytes: 0, overBudgetBytes: 0 };
+  }
+  const candidates = [];
+  for (const name of names) {
+    const match = ARTIFACT_FILE.exec(name);
+    if (!match) continue;
+    const artifactPath = path.join(directory, name);
+    let info;
+    try {
+      info = await stat(artifactPath);
+    } catch {
+      continue;
+    }
+    if (!info.isFile()) continue;
+    const pid = match[1] === void 0 ? Number.NaN : Number.parseInt(match[1], 36);
+    candidates.push({
+      path: artifactPath,
+      bytes: info.size,
+      mtimeMs: info.mtimeMs,
+      held: Number.isInteger(pid) && pid > 0 && alive(pid)
+    });
+  }
+  candidates.sort((left, right) => left.mtimeMs - right.mtimeMs || left.path.localeCompare(right.path));
+  const removed = [];
+  const survivors = [];
+  let keptBytes = 0;
+  for (const candidate of candidates) {
+    if (!candidate.held && now - candidate.mtimeMs >= retention.maxAgeMs) {
+      try {
+        await rm(candidate.path, { force: true });
+        removed.push(candidate.path);
+        continue;
+      } catch {
+      }
+    }
+    survivors.push(candidate);
+    keptBytes += candidate.bytes;
+  }
+  for (const candidate of survivors) {
+    if (keptBytes <= retention.maxBytes) break;
+    if (candidate.held) continue;
+    try {
+      await rm(candidate.path, { force: true });
+    } catch {
+      continue;
+    }
+    removed.push(candidate.path);
+    keptBytes -= candidate.bytes;
+  }
+  let heldBytes = 0;
+  for (const candidate of survivors) {
+    if (candidate.held) heldBytes += candidate.bytes;
+  }
+  return {
+    removed,
+    keptBytes,
+    heldBytes,
+    overBudgetBytes: Math.max(0, keptBytes - retention.maxBytes)
+  };
+};
+var sweepOutputArtifactsIfDue = async (options = {}) => {
+  const now = options.now ?? Date.now();
+  const interval = options.intervalMs ?? OUTPUT_ARTIFACT_SWEEP_INTERVAL_MS;
+  if (sweptAt !== void 0 && now - sweptAt < interval) return void 0;
+  sweptAt = now;
+  const sweep = await sweepOutputArtifacts(options);
+  lastSweep = { ...sweep, at: now };
+  if (sweep.overBudgetBytes > 0) {
+    const cap = (options.retention ?? activeRetention).maxBytes;
+    console.warn(
+      `[omp-fabric] output artifacts keep ${sweep.keptBytes} bytes against a ${cap} byte cap; ${sweep.overBudgetBytes} bytes stay because ${sweep.heldBytes} bytes belong to running sessions`
+    );
+  }
+  return sweep;
+};
+var writeOutputArtifact = async (content) => {
+  const directory = outputArtifactDir();
+  await mkdir(directory, { recursive: true, mode: 448 });
+  const artifactPath = path.join(
+    directory,
+    `output-${Date.now().toString(36)}-p${process.pid.toString(36)}-${randomBytes(6).toString("hex")}.txt`
+  );
+  await writeFile(artifactPath, content, { encoding: "utf8", mode: 384 });
+  try {
+    await sweepOutputArtifactsIfDue({ directory });
+  } catch {
+  }
+  return artifactPath;
+};
+var MAX_ARTIFACT_FAILURE_REASON_CHARS = 160;
+var artifactFailureReason = (error) => {
+  const raw = error instanceof Error ? error.message : String(error);
+  const flattened = raw.replace(/\s+/g, " ").trim();
+  if (!flattened) return "unknown error";
+  return flattened.length <= MAX_ARTIFACT_FAILURE_REASON_CHARS ? flattened : `${flattened.slice(0, MAX_ARTIFACT_FAILURE_REASON_CHARS - 1)}\u2026`;
+};
+var boundModelOutput = async (visible, maxChars, fullOutput = visible, writeArtifact = writeOutputArtifact) => {
+  if (visible.length <= maxChars && fullOutput.length <= maxChars) {
+    return { text: visible, originalChars: fullOutput.length, omittedChars: 0 };
+  }
+  let artifactPath;
+  let failureReason;
+  try {
+    artifactPath = await writeArtifact(fullOutput);
+  } catch (error) {
+    failureReason = artifactFailureReason(error);
+  }
+  const suffix = artifactPath ? `
+
+[Full output (${fullOutput.length} chars) saved to: ${artifactPath}]` : `
+
+[full output ${fullOutput.length} chars; overflow could not be saved: ${failureReason}]`;
+  const bodyBudget = Math.max(1, maxChars - suffix.length);
+  const body = truncateMiddle(visible, bodyBudget);
+  const combined = `${body}${suffix}`;
+  return {
+    text: combined.length <= maxChars ? combined : truncateMiddle(combined, maxChars),
+    ...artifactPath ? { artifactPath } : {},
+    originalChars: fullOutput.length,
+    omittedChars: Math.max(0, fullOutput.length - Math.min(fullOutput.length, body.length))
+  };
+};
+
 // src/config.ts
 var MIN_COMPACTION_TOKEN_THRESHOLD = 1e3;
 var MAX_COMPACTION_TOKEN_THRESHOLD = 1e8;
@@ -360,6 +530,28 @@ var clampCompactionRatioThreshold = (value) => Math.min(
   MAX_COMPACTION_RATIO_THRESHOLD,
   Math.max(MIN_COMPACTION_RATIO_THRESHOLD, value)
 );
+var MIN_SOFT_THRESHOLD_RATIO = 0.1;
+var MAX_SOFT_THRESHOLD_RATIO = 0.95;
+var MIN_HARD_THRESHOLD_RATIO = 0.2;
+var MAX_HARD_THRESHOLD_RATIO = 0.98;
+var SOFT_BELOW_HARD_MARGIN = 0.05;
+var clampSoftThresholdRatio = (value) => value <= 0 ? 0 : Math.min(MAX_SOFT_THRESHOLD_RATIO, Math.max(MIN_SOFT_THRESHOLD_RATIO, value));
+var THRESHOLD_RATIO_STEPS_PER_UNIT = 20;
+var roundThresholdRatio = (value) => Math.round(value * THRESHOLD_RATIO_STEPS_PER_UNIT) / THRESHOLD_RATIO_STEPS_PER_UNIT;
+var clampHardThresholdRatio = (value) => value <= 0 ? 0 : Math.min(MAX_HARD_THRESHOLD_RATIO, Math.max(MIN_HARD_THRESHOLD_RATIO, value));
+var reconcileThresholdRatios = (soft, hard) => {
+  const clampedHard = clampHardThresholdRatio(hard);
+  const clampedSoft = clampSoftThresholdRatio(soft);
+  if (clampedHard > 0 && clampedSoft > 0 && clampedSoft >= clampedHard) {
+    return {
+      soft: clampSoftThresholdRatio(
+        roundThresholdRatio(clampedHard - SOFT_BELOW_HARD_MARGIN)
+      ),
+      hard: clampedHard
+    };
+  }
+  return { soft: clampedSoft, hard: clampedHard };
+};
 var MAX_EXECUTOR_TIMEOUT_MS = 24 * 36e5;
 var MIN_AGENT_TIMEOUT_MS = 1e3;
 var DEFAULT_AGENT_TIMEOUT_MS = 36e5;
@@ -473,6 +665,8 @@ var DEFAULT_FABRIC_CONFIG = {
   compaction: {
     engine: "lcm",
     targetContextRatio: 0.75,
+    softThresholdRatio: 0.55,
+    hardThresholdRatio: 0,
     thresholds: {},
     tokenThresholds: {},
     lcmMaxInputChars: 2e5,
@@ -490,7 +684,9 @@ var DEFAULT_FABRIC_CONFIG = {
   retention: {
     orphanedTempRunMs: 6 * 60 * 60 * 1e3,
     oneShotRunMs: 24 * 60 * 60 * 1e3,
-    actorRunArchiveMs: 7 * 24 * 60 * 60 * 1e3
+    actorRunArchiveMs: 7 * 24 * 60 * 60 * 1e3,
+    outputArtifactMs: DEFAULT_OUTPUT_ARTIFACT_RETENTION.maxAgeMs,
+    outputArtifactMaxBytes: DEFAULT_OUTPUT_ARTIFACT_RETENTION.maxBytes
   },
   mesh: {
     enabled: true,
@@ -656,6 +852,10 @@ var normalizeFabricConfig = (input) => {
       clampCompactionTokenThreshold(tokens)
     ])
   );
+  const thresholdRatios = reconcileThresholdRatios(
+    typeof compaction.softThresholdRatio === "number" && Number.isFinite(compaction.softThresholdRatio) ? compaction.softThresholdRatio : DEFAULT_FABRIC_CONFIG.compaction.softThresholdRatio,
+    typeof compaction.hardThresholdRatio === "number" && Number.isFinite(compaction.hardThresholdRatio) ? compaction.hardThresholdRatio : DEFAULT_FABRIC_CONFIG.compaction.hardThresholdRatio
+  );
   const prewalkModel = stringValue(prewalk.model);
   const prewalkThinking = isFabricThinking(prewalk.thinking) ? prewalk.thinking : void 0;
   const agentModel = stringValue(agents.model);
@@ -975,6 +1175,8 @@ var normalizeFabricConfig = (input) => {
         0.25,
         0.85
       ),
+      softThresholdRatio: thresholdRatios.soft,
+      hardThresholdRatio: thresholdRatios.hard,
       thresholds: compactionThresholds,
       tokenThresholds: compactionTokenThresholds,
       lcmMaxInputChars: boundedInteger(compaction.lcmMaxInputChars, DEFAULT_FABRIC_CONFIG.compaction.lcmMaxInputChars, 1024, 1e6),
@@ -1007,6 +1209,18 @@ var normalizeFabricConfig = (input) => {
         DEFAULT_FABRIC_CONFIG.retention.actorRunArchiveMs,
         60 * 60 * 1e3,
         365 * 24 * 60 * 60 * 1e3
+      ),
+      outputArtifactMs: boundedInteger(
+        retention.outputArtifactMs,
+        DEFAULT_FABRIC_CONFIG.retention.outputArtifactMs,
+        60 * 60 * 1e3,
+        365 * 24 * 60 * 60 * 1e3
+      ),
+      outputArtifactMaxBytes: boundedInteger(
+        retention.outputArtifactMaxBytes,
+        DEFAULT_FABRIC_CONFIG.retention.outputArtifactMaxBytes,
+        1024 * 1024,
+        64 * 1024 * 1024 * 1024
       )
     },
     mesh: {
@@ -1246,12 +1460,12 @@ var planConfigFile = (filePath) => {
 };
 var writeJsonAtomic = (filePath, document, expectedSource) => {
   const resolvedPath = fs.existsSync(filePath) ? fs.realpathSync(filePath) : filePath;
-  const directory = path.dirname(resolvedPath);
+  const directory = path2.dirname(resolvedPath);
   if (!fs.existsSync(directory)) fs.mkdirSync(directory, { recursive: true });
   const mode = fs.existsSync(resolvedPath) ? fs.statSync(resolvedPath).mode & 511 : 384;
-  const temporaryPath = path.join(
+  const temporaryPath = path2.join(
     directory,
-    `.${path.basename(resolvedPath)}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`
+    `.${path2.basename(resolvedPath)}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`
   );
   let descriptor;
   try {
@@ -1297,8 +1511,8 @@ var writeJsonAtomic = (filePath, document, expectedSource) => {
 var resolveFabricConfig = (options, includeProject, applyEnvironmentOverrides) => {
   let merged = structuredClone(DEFAULT_FABRIC_CONFIG);
   const plans = [
-    planConfigFile(path.join(options.agentDir, "fabric.json")),
-    ...includeProject ? [planConfigFile(path.join(options.cwd, ".omp", "fabric.json"))] : []
+    planConfigFile(path2.join(options.agentDir, "fabric.json")),
+    ...includeProject ? [planConfigFile(path2.join(options.cwd, ".omp", "fabric.json"))] : []
   ].filter((plan) => plan !== void 0);
   for (const plan of plans) {
     if (plan.changed) writeJsonAtomic(plan.path, plan.document, plan.source);
@@ -1318,6 +1532,10 @@ var loadFabricConfigForScope = (options, scope) => {
 };
 var loadFabricConfig = (options) => {
   const config = resolveFabricConfig(options, options.projectTrusted, true);
+  configureOutputArtifactRetention({
+    maxAgeMs: config.retention.outputArtifactMs,
+    maxBytes: config.retention.outputArtifactMaxBytes
+  });
   return config;
 };
 var saveFabricConfig = (options, partial) => {
@@ -1325,7 +1543,7 @@ var saveFabricConfig = (options, partial) => {
   if (scope === "project" && !options.projectTrusted) {
     throw new Error("Cannot save project Fabric configuration for an untrusted project");
   }
-  const targetPath = scope === "project" ? path.join(options.cwd, ".omp", "fabric.json") : path.join(options.agentDir, "fabric.json");
+  const targetPath = scope === "project" ? path2.join(options.cwd, ".omp", "fabric.json") : path2.join(options.agentDir, "fabric.json");
   if (Object.hasOwn(partial, "configVersion") || Object.hasOwn(partial, "subagents")) {
     throw new Error("Fabric configuration updates must use the current schema");
   }
@@ -1341,7 +1559,7 @@ var saveFabricConfig = (options, partial) => {
 };
 
 // src/core/agent-dir.ts
-import path2 from "node:path";
+import path3 from "node:path";
 import { fileURLToPath } from "node:url";
 import { homedir } from "node:os";
 import { getAgentDir } from "@oh-my-pi/pi-utils";
@@ -1349,7 +1567,7 @@ var expandEnvDir = (envDir) => {
   if (/^file:\/\//.test(envDir)) return fileURLToPath(envDir);
   if (envDir === "~") return homedir();
   if (envDir.startsWith("~/") || process.platform === "win32" && envDir.startsWith("~\\")) {
-    return path2.join(homedir(), envDir.slice(2));
+    return path3.join(homedir(), envDir.slice(2));
   }
   return envDir;
 };
@@ -1364,6 +1582,8 @@ export {
   normalizeModelAliases,
   resolveFabricModel,
   resolveAvailableOmpModel,
+  modelOutputBudget,
+  boundModelOutput,
   MIN_COMPACTION_TOKEN_THRESHOLD,
   MAX_COMPACTION_TOKEN_THRESHOLD,
   MIN_COMPACTION_RATIO_THRESHOLD,
@@ -1381,4 +1601,4 @@ export {
   saveFabricConfig,
   resolveAgentDir
 };
-//# sourceMappingURL=chunk-Z7HQ6FYW.js.map
+//# sourceMappingURL=chunk-ANAXFBUE.js.map