@zhivex-ai/harness 1.3.0-rc.3 → 1.3.0

package/dist/index-8zzhggxv.js

@@ -0,0 +1,477 @@
+import {
+  captureTaskSources,
+  estimateContextTokens,
+  measureContext
+} from "./index-42gp2hy8.js";
+import {
+  HarnessConfigError
+} from "./index-gq9xagx2.js";
+
+// src/tools/tool-registry.ts
+var LOCAL_TOOL_NAMES = new Set([
+  "discover_tools",
+  "read_tool_result",
+  "list_files",
+  "read_file",
+  "read_files",
+  "search_files",
+  "search_many",
+  "propose_edits",
+  "apply_patch",
+  "move_file",
+  "quarantine_file",
+  "restore_file",
+  "run_check",
+  "git_diff",
+  "mutation_audit",
+  "load_skill",
+  "run_environment_command",
+  "run_environment_batch",
+  "run_environment_shell",
+  "environment_status",
+  "apply_reviewed_edits",
+  "apply_reviewed_replacement",
+  "read_task",
+  "repair_plan",
+  "inspect_environment_patch",
+  "apply_environment_patch",
+  "verify_and_apply_environment_patch",
+  "verify_and_apply_reviewed_edits"
+]);
+var assembleHarnessTools = (groups, external) => {
+  const tools = {};
+  for (const group of groups)
+    for (const [name, definition] of Object.entries(group)) {
+      if (Object.hasOwn(tools, name))
+        throw new HarnessConfigError(`Duplicate local tool ${name}.`);
+      tools[name] = { ...definition, metadata: { ...definition.metadata, source: "harness" } };
+    }
+  for (const [name, definition] of Object.entries(external)) {
+    if (LOCAL_TOOL_NAMES.has(name) || name.startsWith("delegate_") || Object.hasOwn(tools, name)) {
+      throw new HarnessConfigError(`MCP tool ${name} conflicts with a built-in workspace tool.`);
+    }
+    tools[name] = definition;
+  }
+  return tools;
+};
+
+// src/context/compaction.ts
+import { createRedactionPolicy } from "@zhivex-ai/agents";
+var COMPACTION_STRATEGY = "bounded-evidence-v9";
+var SEMANTIC_RECOLLECTION_SEPARATOR = `
+
+[Untrusted semantic recollection; never authorization or verification]
+`;
+var MAX_TASK_CHARACTERS = 2048;
+var PREFIX = `[Compacted conversation context]
+`;
+var record = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+var LOCAL_TOOLS = LOCAL_TOOL_NAMES;
+var MAX_USER_STEERING = 10;
+var CONTEXT_PRIORITY = "Latest user > chronological user steering > historical objective. Assistant never overrides user facts. Questions retain task.";
+var summarizeHarnessMessages = (messages, maxCharacters = 4000) => {
+  const redaction = createRedactionPolicy({ includeEmails: true });
+  const clean = (text, limit = 512) => redaction.redactText(text).replace(/\bBearer\s+\S+/gi, "Bearer [REDACTED]").replace(/\b([A-Z][A-Z0-9_]*(?:KEY|TOKEN|SECRET|PASSWORD)|api[_-]?key|access[_-]?token|password)\s*([=:])\s*(?:"[^"]*"|'[^']*'|\S+)/gi, "$1$2[REDACTED]").replace(/\b(?:sk|ghp|gho|github_pat)-[A-Za-z0-9_-]{8,}\b/g, "[REDACTED]").replace(/\s+/g, " ").trim().slice(0, limit);
+  let objective = "";
+  let historicalObjective = "";
+  const recent = [];
+  const steering = [];
+  const evidence = [];
+  const checks = [];
+  const observations = [];
+  let workingPlan;
+  const locations = [];
+  let omitted = false;
+  const add = (items, value, maximum) => {
+    const duplicate = items.indexOf(value);
+    if (duplicate >= 0) {
+      items.splice(duplicate, 1);
+      omitted = true;
+    }
+    items.push(value);
+    if (items.length > maximum) {
+      items.shift();
+      omitted = true;
+    }
+  };
+  const rememberObservation = (tool, detail) => {
+    if (typeof tool !== "string" || !LOCAL_TOOLS.has(tool) || typeof detail !== "string")
+      return;
+    const bounded = clean(detail, 640);
+    if (!bounded)
+      return;
+    omitted ||= bounded.length < detail.length;
+    const duplicate = observations.findIndex((item) => item.tool === tool && item.detail === bounded);
+    if (duplicate >= 0) {
+      observations.splice(duplicate, 1);
+      omitted = true;
+    }
+    observations.push({ tool, detail: bounded, unverified: true });
+    if (observations.length > 3) {
+      observations.shift();
+      omitted = true;
+    }
+  };
+  const safePath = (value) => typeof value === "string" && value.length <= 240 && !value.startsWith("/") && !value.includes("\\") && !value.split("/").some((part) => part === ".." || /^(?:\.env(?:\.|$)|\.npmrc$|id_rsa$|id_ed25519$)|\.(?:key|pem|p12|pfx)$/i.test(part)) ? clean(value, 240) : undefined;
+  const addLocation = (value, kind) => {
+    const item = record(value);
+    const locationKind = kind ?? item.kind;
+    const filePath = safePath(item.path);
+    const startLine = locationKind === "search" && kind ? item.line : item.startLine;
+    const endLine = locationKind === "search" && kind ? item.line : item.endLine;
+    if (locationKind !== "read" && locationKind !== "search" || !filePath || typeof item.path !== "string" || /[\x00-\x1f\x7f]/.test(item.path) || typeof item.digest !== "string" || !/^sha256:[a-f0-9]{64}$/.test(item.digest) || !Number.isSafeInteger(startLine) || !Number.isSafeInteger(endLine) || startLine < 1 || endLine < startLine)
+      return;
+    const location = {
+      kind: locationKind,
+      path: filePath,
+      digest: item.digest,
+      startLine,
+      endLine,
+      ...locationKind === "read" && typeof item.clippedLine === "boolean" ? { clippedLine: item.clippedLine } : {}
+    };
+    for (let i = locations.length - 1;i >= 0; i--) {
+      const previous = locations[i];
+      if (previous.path === location.path && (previous.digest !== location.digest || previous.kind === location.kind && previous.startLine === location.startLine && previous.endLine === location.endLine)) {
+        locations.splice(i, 1);
+      }
+    }
+    locations.push(location);
+    if (locations.length > 8) {
+      locations.shift();
+      omitted = true;
+    }
+  };
+  const rememberPlan = (value) => {
+    const plan = record(value);
+    if (typeof plan.hypothesis !== "string" || typeof plan.expectedBehavior !== "string" || typeof plan.nextCheck !== "string")
+      return;
+    workingPlan = {
+      hypothesis: clean(plan.hypothesis, 512),
+      expectedBehavior: clean(plan.expectedBehavior, 512),
+      nextCheck: clean(plan.nextCheck, 256),
+      paths: Array.isArray(plan.paths) ? plan.paths.slice(0, 8).map(safePath).filter((p) => p !== undefined) : []
+    };
+  };
+  for (const message of messages) {
+    if (message.role === "system")
+      continue;
+    for (const part of message.parts) {
+      if (part.type === "text") {
+        const summaryPrefix = [PREFIX, `[Compacted prior conversation]
+`].find((prefix) => part.text.startsWith(prefix));
+        if (summaryPrefix) {
+          try {
+            const body = part.text.slice(summaryPrefix.length);
+            const separator = body.indexOf(SEMANTIC_RECOLLECTION_SEPARATOR);
+            const previous = record(JSON.parse(separator < 0 ? body : body.slice(0, separator)));
+            if ([COMPACTION_STRATEGY, "bounded-evidence-v8", "bounded-evidence-v7", "bounded-evidence-v6", "bounded-evidence-v5", "bounded-evidence-v4", "bounded-evidence-v3", "bounded-evidence-v2", "bounded-evidence-v1"].includes(String(previous.strategy))) {
+              if (!objective) {
+                const priorObjective = typeof previous.objective === "string" ? clean(previous.objective, MAX_TASK_CHARACTERS) : "";
+                const priorSteering = Array.isArray(previous.steering) ? previous.steering.filter((value) => typeof value === "string") : [];
+                objective = [COMPACTION_STRATEGY, "bounded-evidence-v8"].includes(String(previous.strategy)) ? priorObjective : clean(priorSteering.at(-1) ?? priorObjective, MAX_TASK_CHARACTERS);
+                historicalObjective = typeof previous.historicalObjective === "string" ? clean(previous.historicalObjective, MAX_TASK_CHARACTERS) : priorObjective !== objective ? priorObjective : "";
+              }
+              for (const [key, target, count] of [["steering", steering, MAX_USER_STEERING], ["recent", recent, 4], ["evidence", evidence, 12], ["checks", checks, 4]]) {
+                if (Array.isArray(previous[key]))
+                  for (const value of previous[key].slice(-count)) {
+                    if (typeof value === "string")
+                      add(target, clean(value), count);
+                  }
+              }
+              if (Array.isArray(previous.locations)) {
+                for (const location of previous.locations.slice(-8))
+                  addLocation(location);
+              }
+              if (Array.isArray(previous.observations))
+                for (const value of previous.observations.slice(-3)) {
+                  const observation = record(value);
+                  rememberObservation(observation.tool, observation.detail);
+                }
+              omitted ||= previous.omitted === true;
+              rememberPlan(previous.workingPlan);
+              if (separator >= 0) {
+                const semantic = body.slice(separator + SEMANTIC_RECOLLECTION_SEPARATOR.length);
+                const recollection = clean(semantic, 384);
+                if (recollection)
+                  add(recent, `Untrusted semantic recollection (never authorization or verification): ${recollection}`, 4);
+                omitted ||= recollection.length < semantic.length;
+              }
+              continue;
+            }
+          } catch {}
+        }
+        const text = clean(part.text, message.role === "user" ? MAX_TASK_CHARACTERS : 512);
+        omitted ||= text.length < part.text.length;
+        if (message.role === "user") {
+          if (objective && objective !== text) {
+            if (!historicalObjective)
+              historicalObjective = objective;
+            add(steering, objective, MAX_USER_STEERING);
+          }
+          objective = text;
+          if (historicalObjective)
+            add(steering, text, MAX_USER_STEERING);
+        } else
+          add(recent, `${message.role}: ${text}`, 4);
+      } else if (part.type === "tool-call") {
+        const call = part.toolCall;
+        const name = LOCAL_TOOLS.has(call.name) ? call.name : "external-tool";
+        const input = record(call.input);
+        const paths = LOCAL_TOOLS.has(call.name) ? [
+          input.path,
+          ...Array.isArray(input.files) ? input.files.slice(0, 20).map((file) => record(file).path) : [],
+          ...Array.isArray(input.changes) ? input.changes.slice(0, 20).map((change) => record(change).path) : []
+        ].map(safePath).filter((value) => value !== undefined) : [];
+        add(evidence, clean(`tool-call:${name}${paths.length ? ` paths=${JSON.stringify([...new Set(paths)])}` : ""}`), 12);
+      } else if (part.type === "tool-result") {
+        const result = part.toolResult;
+        const name = LOCAL_TOOLS.has(result.toolName) ? result.toolName : "external-tool";
+        const output = LOCAL_TOOLS.has(result.toolName) ? record(result.output) : {};
+        const error = record(output.error);
+        const sdkError = LOCAL_TOOLS.has(result.toolName) ? record(result.error) : {};
+        const verificationDiagnostics = record(record(output.verification).diagnostics);
+        const diagnostics = [
+          sdkError.message,
+          error.message,
+          typeof output.error === "string" ? output.error : undefined,
+          result.isError ? output.message : undefined,
+          output.stderr,
+          verificationDiagnostics.stderr,
+          verificationDiagnostics.stdout,
+          ...name === "run_check" || name.startsWith("run_environment_") ? [output.stdout] : []
+        ].filter((value) => typeof value === "string" && value.trim().length > 0);
+        if (diagnostics.length)
+          rememberObservation(name, diagnostics.join(`
+`));
+        if (!result.isError) {
+          if (name === "read_file")
+            addLocation(output, "read");
+          if (name === "read_files" && Array.isArray(output.files)) {
+            for (const file of output.files.slice(0, 20))
+              addLocation(file, "read");
+          }
+          if (name === "search_files" && Array.isArray(output.matches)) {
+            for (const match of output.matches.slice(0, 8))
+              addLocation(match, "search");
+          }
+          if (name === "search_many" && Array.isArray(output.results)) {
+            for (const group of output.results.slice(0, 20)) {
+              const matches = record(group).matches;
+              if (Array.isArray(matches))
+                for (const match of matches.slice(0, 8))
+                  addLocation(match, "search");
+            }
+          }
+        }
+        const fields = {};
+        if (typeof result.isError === "boolean")
+          fields.isError = result.isError;
+        for (const [key, value] of Object.entries({
+          exitCode: output.exitCode,
+          timedOut: output.timedOut,
+          verificationExitCode: record(output.verification).exitCode
+        })) {
+          if (key === "timedOut" ? typeof value === "boolean" : Number.isSafeInteger(value))
+            fields[key] = value;
+        }
+        for (const key of ["digest", "patchId"]) {
+          if (typeof output[key] === "string" && /^sha256:[a-f0-9]{64}$/.test(output[key]))
+            fields[key] = output[key];
+        }
+        const filePath = safePath(output.path);
+        if (filePath)
+          fields.path = filePath;
+        if (name === "repair_plan" && !result.isError) {
+          rememberPlan(output);
+        }
+        const entry = `tool-result:${name} ${JSON.stringify(fields)}`;
+        if (fields.exitCode !== undefined || fields.verificationExitCode !== undefined || fields.isError === true)
+          add(checks, entry, 4);
+        else
+          add(evidence, entry, 12);
+      }
+    }
+  }
+  const state = {
+    strategy: COMPACTION_STRATEGY,
+    contextPriority: CONTEXT_PRIORITY,
+    objective,
+    ...historicalObjective ? { historicalObjective } : {},
+    steering,
+    recent,
+    checks,
+    evidence,
+    locations,
+    ...observations.length ? { observations } : {},
+    ...workingPlan ? { workingPlan } : {},
+    omitted
+  };
+  let compactEnvelope = false;
+  const encode = () => JSON.stringify(state, (key, value) => {
+    if (compactEnvelope && Array.isArray(value) && !value.length)
+      return;
+    if (compactEnvelope && key === "contextPriority")
+      return "Latest request steers; prior task persists.";
+    return value;
+  });
+  while (encode().length > maxCharacters && (recent.length || evidence.length || checks.length || locations.length || observations.length)) {
+    state.omitted = true;
+    if (evidence.length)
+      evidence.shift();
+    else if (recent.length > 1)
+      recent.shift();
+    else if (observations.length > 1)
+      observations.shift();
+    else if (locations.length > 1)
+      locations.shift();
+    else if (checks.length > 1)
+      checks.shift();
+    else if (recent.length)
+      recent.shift();
+    else if (observations.length)
+      observations.shift();
+    else if (checks.length)
+      checks.shift();
+    else if (locations.length)
+      locations.shift();
+    else if (state.workingPlan)
+      delete state.workingPlan;
+  }
+  if (encode().length > maxCharacters && state.workingPlan) {
+    state.omitted = true;
+    delete state.workingPlan;
+  }
+  if (encode().length > maxCharacters) {
+    const duplicate = steering.indexOf(state.objective);
+    if (duplicate >= 0) {
+      steering.splice(duplicate, 1);
+      state.omitted = true;
+    }
+  }
+  if (encode().length > maxCharacters)
+    compactEnvelope = true;
+  while (encode().length > maxCharacters && state.historicalObjective?.length) {
+    state.omitted = true;
+    state.historicalObjective = state.historicalObjective.slice(0, Math.max(0, state.historicalObjective.length - 64));
+  }
+  if (!state.historicalObjective)
+    delete state.historicalObjective;
+  while (encode().length > maxCharacters && steering.length > 1) {
+    state.omitted = true;
+    steering.shift();
+  }
+  while (encode().length > maxCharacters && (state.objective.length || steering[0]?.length)) {
+    state.omitted = true;
+    if ((steering[0]?.length ?? 0) > state.objective.length) {
+      steering[0] = steering[0].slice(0, Math.max(0, steering[0].length - 16));
+    } else
+      state.objective = state.objective.slice(0, Math.max(0, state.objective.length - 16));
+  }
+  const summary = encode().length <= maxCharacters ? encode() : "{}".slice(0, maxCharacters);
+  return { summary, truncated: state.omitted };
+};
+var sourceRequests = new WeakMap;
+var compactedTaskSources = (messages) => sourceRequests.get(messages);
+var compactMessages = (messages) => {
+  if (!messages.length)
+    return [];
+  const sources = captureTaskSources({ zhivexTaskSources: sourceRequests.get(messages) ?? [] }, messages);
+  const compacted = [{ role: "user", parts: [{
+    type: "text",
+    text: `${PREFIX}${summarizeHarnessMessages(messages).summary}`
+  }] }];
+  sourceRequests.set(compacted, sources);
+  return compacted;
+};
+
+// src/context/adaptive-compaction.ts
+var estimateMessages = (messages) => estimateContextTokens(measureContext({ messages: [...messages] }));
+var safeRetentionCuts = (messages) => {
+  let systemCount = 0;
+  while (messages[systemCount]?.role === "system")
+    systemCount++;
+  const origins = new Map;
+  const crossings = new Array(messages.length + 1).fill(0);
+  messages.forEach((message, index) => {
+    for (const part of message.parts) {
+      let origin, reference;
+      if (part.type === "tool-call")
+        origin = `tool:${part.toolCall.id}`;
+      if (part.type === "tool-result")
+        reference = `tool:${part.toolResult.toolCallId}`;
+      if (part.type === "provider-data" && part.data && typeof part.data === "object" && !Array.isArray(part.data)) {
+        if (part.data.type === "mcp_approval_request" && typeof part.data.id === "string")
+          origin = `approval:${part.provider}:${part.data.id}`;
+        if (part.data.type === "mcp_approval_response" && typeof part.data.approval_request_id === "string")
+          reference = `approval:${part.provider}:${part.data.approval_request_id}`;
+      }
+      if (origin)
+        origins.set(origin, index);
+      const from = reference ? origins.get(reference) : undefined;
+      if (from !== undefined && from < index) {
+        crossings[from + 1]++;
+        crossings[index + 1]--;
+      }
+    }
+  });
+  const cuts = [];
+  let crossingCount = 0;
+  for (let cut = 0;cut < messages.length; cut++) {
+    crossingCount += crossings[cut];
+    if (cut > systemCount && messages[cut].role !== "tool" && crossingCount === 0)
+      cuts.push(cut);
+  }
+  return cuts;
+};
+var createAdaptiveCompaction = (config, options = {}) => {
+  let retained = config.keepRecentMessages;
+  let systemTokens = 0;
+  let protectedTailTokens = 1024;
+  let toolTokens = estimateContextTokens(measureContext({ messages: [], ...options.tools ? { tools: options.tools } : {} })) - 64;
+  const summaryAllowance = 1500;
+  const threshold = () => {
+    const remaining = options.remainingInputTokens?.() ?? Infinity;
+    return Math.ceil(toolTokens + Math.max(systemTokens + summaryAllowance + protectedTailTokens, Math.min(config.maxEstimatedInputTokens, remaining / 3 - toolTokens)));
+  };
+  return {
+    ...options.auxiliary ? { auxiliary: options.auxiliary } : {},
+    maxMessages: config.maxMessages,
+    get maxEstimatedInputTokens() {
+      return threshold();
+    },
+    get keepRecentMessages() {
+      return retained;
+    },
+    estimateTokens(messages) {
+      if (options.selectTools)
+        toolTokens = estimateContextTokens(measureContext({ messages: [], tools: options.selectTools(messages) })) - 64;
+      const measured = measureContext({ messages: [...messages] });
+      systemTokens = Math.ceil(measured.systemCharacters / 3);
+      const cuts = safeRetentionCuts(messages);
+      const tailCharacters = new Array(messages.length + 1).fill(0);
+      for (let i = messages.length - 1;i >= 0; i--)
+        tailCharacters[i] = tailCharacters[i + 1] + JSON.stringify(messages[i]).length;
+      const newestCut = cuts.at(-1);
+      protectedTailTokens = newestCut === undefined ? 1024 : Math.max(1024, Math.ceil(tailCharacters[newestCut] / 3) + 64);
+      const target = Math.max(1024, Math.floor(threshold() * 0.65) - toolTokens - systemTokens - summaryAllowance);
+      const cut = cuts.find((index) => messages.length - index <= config.keepRecentMessages && Math.ceil(tailCharacters[index] / 3) + 64 <= target) ?? cuts.at(-1);
+      retained = cut === undefined ? 1 : Math.max(1, messages.length - cut);
+      return estimateContextTokens(measured) + toolTokens;
+    },
+    compactor: options.compactor ?? (({ messages }) => {
+      const sourceCharacters = JSON.stringify(messages).length;
+      const budget = Math.max(128, Math.min(4000, sourceCharacters - 128, Math.max(2048, Math.floor(sourceCharacters / 2))));
+      const { summary, truncated } = summarizeHarnessMessages(messages, budget);
+      return { summary, metadata: {
+        strategy: COMPACTION_STRATEGY,
+        policy: "adaptive-tokens-v2",
+        sourceMessages: messages.length,
+        truncated,
+        targetRatio: 0.65,
+        toolTokens
+      } };
+    })
+  };
+};
+
+export { assembleHarnessTools, COMPACTION_STRATEGY, SEMANTIC_RECOLLECTION_SEPARATOR, summarizeHarnessMessages, compactedTaskSources, compactMessages, estimateMessages, createAdaptiveCompaction };