@agentskit/harness 0.11.0 → 0.12.0

package/dist/cli.js

@@ -2503,6 +2503,21 @@ var orcaStatus = async (runner, options2 = {}) => parseOrcaStatus(await orcaJson
 var orcaWorktrees = async (runner, options2 = {}) => parseOrcaWorktrees(await orcaJson(runner, ["worktree", "ps"], options2));
 var orcaAgentHooks = async (runner, options2 = {}) => parseOrcaAgentHooks(await orcaJson(runner, ["agent", "hooks", "status"], options2));
 var orcaAccountList = async (runner, options2 = {}) => orcaJson(runner, ["account", "list"], options2);
+var orcaDiagnosticsMemory = async (runner, options2 = {}) => {
+  try {
+    const result = await orcaJson(runner, ["diagnostics", "memory"], options2);
+    if (!isRecord7(result)) return null;
+    const host = isRecord7(result["host"]) ? result["host"] : {};
+    const availableBytes = host["availableMemory"];
+    if (typeof availableBytes !== "number" || !Number.isFinite(availableBytes) || availableBytes <= 0) return null;
+    const totalBytes = typeof host["totalMemory"] === "number" ? host["totalMemory"] : null;
+    const worktrees = Array.isArray(result["worktrees"]) ? result["worktrees"] : [];
+    const agentRssSamples = worktrees.filter(isRecord7).flatMap((worktree) => Array.isArray(worktree["sessions"]) ? worktree["sessions"] : []).filter(isRecord7).map((session) => session["memory"]).filter((value) => typeof value === "number" && Number.isFinite(value) && value > 0);
+    return { availableBytes, totalBytes, agentRssSamples };
+  } catch {
+    return null;
+  }
+};
 var parseOrcaWorktreeCreate = (result) => {
   const record3 = isRecord7(result) ? result : {};
   const nested = isRecord7(record3["worktree"]) ? record3["worktree"] : record3;
@@ -2578,6 +2593,12 @@ var orcaTerminalWait = async (runner, input, options2 = {}) => {
   const wait = isRecord7(record3["wait"]) ? record3["wait"] : record3;
   return { satisfied: wait["satisfied"] === true, raw: result };
 };
+var orcaTerminalScreen = async (runner, input, options2 = {}) => {
+  const result = await orcaJson(runner, ["terminal", "read", "--terminal", input.terminal, "--screen"], options2);
+  const record3 = isRecord7(result) ? isRecord7(result["terminal"]) ? result["terminal"] : result : {};
+  const screen = record3["tail"] ?? record3["screen"] ?? record3["lines"] ?? record3["text"] ?? record3["output"];
+  return Array.isArray(screen) ? screen.map((line2) => isRecord7(line2) ? str(line2["text"], str(line2["line"])) : String(line2)).join("\n") : typeof screen === "string" ? screen : "";
+};
 var parseOrcaAutomations = (result) => {
   const list2 = isRecord7(result) ? Array.isArray(result["automations"]) ? result["automations"] : Array.isArray(result["items"]) ? result["items"] : [] : Array.isArray(result) ? result : [];
   return list2.filter(isRecord7).map((item) => ({ id: str(item["id"]), name: str(item["name"]), enabled: item["enabled"] !== false && item["disabled"] !== true, trigger: str(item["rrule"], str(item["trigger"], str(item["schedule"], typeof item["schedule"] === "object" && item["schedule"] !== null ? JSON.stringify(item["schedule"]) : ""))), provider: str(item["agentId"], str(item["provider"], str(item["agent"]))) || null, raw: item })).filter((item) => item.id);
@@ -3194,8 +3215,8 @@ var isWsl = (platform = process.platform, osRelease = release(), env = process.e
 var assessSlots = (input) => {
   const platform = input.platform ?? process.platform;
   const wsl = isWsl(platform, input.osRelease);
-  const freeBytes = input.freeBytes ?? availableMemoryBytes(platform);
-  const totalBytes = input.totalBytes ?? totalmem();
+  const freeBytes = input.freeBytes ?? input.orcaMemory?.availableBytes ?? availableMemoryBytes(platform);
+  const totalBytes = input.totalBytes ?? input.orcaMemory?.totalBytes ?? totalmem();
   const sample = input.sample ?? { ...sampleMachine(), memoryUsedPercent: Number(Math.max(0, Math.min(100, (1 - freeBytes / Math.max(1, totalBytes)) * 100)).toFixed(2)) };
   const freeRamGb = Number((freeBytes / 1024 ** 3).toFixed(2));
   const reasons = [];
@@ -3203,9 +3224,11 @@ var assessSlots = (input) => {
   const adaptive = adaptiveConcurrency(ceiling, sample, { warningPercent: input.machine.warningPercent, criticalPercent: input.machine.criticalPercent });
   if (adaptive < ceiling) reasons.push(`machine pressure capped concurrency at ${adaptive} (load ${sample.load1PerCpuPercent}%, memory ${sample.memoryUsedPercent}%)`);
   const reservedBytes = input.machine.minFreeRamGb * 1024 ** 3;
-  const perAgentBytes = input.machine.agentRssMb * 1024 ** 2;
+  const measuredAgentBytes = input.orcaMemory?.agentRssSamples.length ? input.orcaMemory.agentRssSamples.reduce((total, value) => total + value, 0) / input.orcaMemory.agentRssSamples.length : null;
+  const perAgentBytes = measuredAgentBytes ?? input.machine.agentRssMb * 1024 ** 2;
+  const perAgentMb = Math.round(perAgentBytes / 1024 ** 2);
   const ramBound = Math.max(0, Math.floor((freeBytes - reservedBytes) / perAgentBytes)) + input.running;
-  if (ramBound < adaptive) reasons.push(`free RAM ${freeRamGb} GB minus ${input.machine.minFreeRamGb} GB reserve fits ${Math.max(0, ramBound - input.running)} more agent(s) at ${input.machine.agentRssMb} MB each`);
+  if (ramBound < adaptive) reasons.push(`free RAM ${freeRamGb} GB minus ${input.machine.minFreeRamGb} GB reserve fits ${Math.max(0, ramBound - input.running)} more agent(s) at ${perAgentMb} MB each${measuredAgentBytes ? " (measured)" : ""}`);
   let maxAgents = Math.min(adaptive, ramBound);
   if (wsl && maxAgents > input.machine.wslCap) {
     maxAgents = input.machine.wslCap;
@@ -3855,7 +3878,8 @@ var runLoopDoctor = async (input) => {
     push("orca.worktrees", "warning", `worktree ps unavailable: ${workersError}`);
   }
   const running = countRunningWorkers(worktrees);
-  const machine = assessSlots({ machine: config.machine, running, platform: input.platform });
+  const orcaMemory = await orcaDiagnosticsMemory(input.runner, orcaOptions2);
+  const machine = assessSlots({ machine: config.machine, running, platform: input.platform, orcaMemory });
   push("machine.slots", machine.free > 0 ? "passed" : "warning", `${machine.free} free of ${machine.maxAgents} (running ${running}, cpus ${machine.sample.cpus}, load ${machine.sample.load1PerCpuPercent}%, free RAM ${machine.freeRamGb} GB)${machine.reasons.length ? `; ${machine.reasons.join("; ")}` : ""}`);
   let queue = [];
   let queueError = null;
@@ -4747,11 +4771,12 @@ var gatherLoopState = async (input) => {
   const { config } = input.loaded;
   const person = queueOwner(input.loaded);
   const orca = { bin: config.orca.bin, timeoutMs: config.orca.timeoutMs };
-  const [accountList, agentHooks, worktrees, queue] = await Promise.all([
+  const [accountList, agentHooks, worktrees, queue, orcaMemory] = await Promise.all([
     orcaAccountList(input.runner, orca).catch(() => ({})),
     orcaAgentHooks(input.runner, orca).catch(() => ({})),
     orcaWorktrees(input.runner, orca),
-    fetchLinearQueue(input.runner, { bin: config.orca.bin, workspaceId: config.linear.workspaceId, teamKey: config.linear.teamKey, assignee: person, filter: config.linear, orca })
+    fetchLinearQueue(input.runner, { bin: config.orca.bin, workspaceId: config.linear.workspaceId, teamKey: config.linear.teamKey, assignee: person, filter: config.linear, orca }),
+    orcaDiagnosticsMemory(input.runner, orca)
   ]);
   const providers = await detectProviders({ providers: providerSpecs(config), accountList, agentHooks, env: input.env, platform: input.platform, exhaustedPercent: config.models.cooldown.exhaustedPercent, cooldowns: activeCooldowns(readCooldowns(input.loaded.stateDir), input.now()), now: input.now });
   const availableIds = providers.filter((provider) => provider.available).map((provider) => provider.id);
@@ -4766,7 +4791,7 @@ var gatherLoopState = async (input) => {
   })]))) : {};
   const routing = routeAllRoles(config, providers, extrasByRole);
   const running = countRunningWorkers(worktrees);
-  const slots = assessSlots({ machine: config.machine, running, platform: input.platform, ...input.machine });
+  const slots = assessSlots({ machine: config.machine, running, platform: input.platform, orcaMemory, ...input.machine });
   const leases = input.ledger.active();
   const busy = busyIssues(queue, leases, worktrees, person);
   const candidates = queue.filter((issue) => !busy.has(issue.identifier) && (!input.onlyIssue || issue.identifier === input.onlyIssue));
@@ -5278,14 +5303,34 @@ ${JSON.stringify(stored.contract, null, 2)}
     return false;
   }
 };
+var captureWorkerOutput = async (ctx, terminal2) => {
+  if (!terminal2) return null;
+  try {
+    const screen = (await orcaTerminalScreen(ctx.runner, { terminal: terminal2 }, orcaOptions(ctx.config))).trim();
+    return screen ? screen.slice(-2e3) : null;
+  } catch {
+    return null;
+  }
+};
 var escalateLinear = async (ctx, record3, kind, body2, actions) => {
   if (ctx.dryRun) {
     actions.push(`would mark ${kind} in Linear and Orca`);
     return;
   }
+  const workerOutput = await captureWorkerOutput(ctx, record3.terminal);
+  const fullBody = workerOutput ? `${body2}
+
+<details><summary>Worker's last terminal output</summary>
+
+\`\`\`
+${workerOutput}
+\`\`\`
+
+</details>` : body2;
+  if (workerOutput) actions.push("captured worker terminal output for the escalation");
   const linear = linearOptions(ctx.config);
   try {
-    await linearCommentAdd(ctx.runner, { issue: record3.issue, body: `${body2}
+    await linearCommentAdd(ctx.runner, { issue: record3.issue, body: `${fullBody}
 
 <!-- loop:${kind}:${record3.leaseId} -->`, dedupeKey: `${kind}:${record3.issue}:${record3.leaseId}` }, linear);
     await linearLabelAdd(ctx.runner, { issue: record3.issue, labels: [ctx.config.linear.blockedLabel] }, linear);