@integrity-labs/agt-cli 0.28.425 → 0.28.427

package/dist/bin/agt.js

@@ -40,7 +40,7 @@ import {
   success,
   table,
   warn
-} from "../chunk-M3L6HOYG.js";
+} from "../chunk-QXEUCIOC.js";
 import {
   AnchorSessionClient,
   CHANNEL_REGISTRY,
@@ -70,7 +70,7 @@ import {
   renderTemplate,
   resolveChannels,
   serializeManifestForSlackCli
-} from "../chunk-PR3IJAMV.js";
+} from "../chunk-NSG3PTR6.js";
 import "../chunk-XWVM4KPK.js";
 
 // src/bin/agt.ts
@@ -4829,7 +4829,7 @@ import { execFileSync, execSync } from "child_process";
 import { existsSync as existsSync10, realpathSync as realpathSync2 } from "fs";
 import chalk18 from "chalk";
 import ora16 from "ora";
-var cliVersion = true ? "0.28.425" : "dev";
+var cliVersion = true ? "0.28.427" : "dev";
 async function fetchLatestVersion() {
   const host2 = getHost();
   if (!host2) return null;
@@ -6001,7 +6001,7 @@ function handleError(err) {
 }
 
 // src/bin/agt.ts
-var cliVersion2 = true ? "0.28.425" : "dev";
+var cliVersion2 = true ? "0.28.427" : "dev";
 var program = new Command();
 program.name("agt").description("Augmented CLI \u2014 agent provisioning and management").version(cliVersion2).option("--json", "Emit machine-readable JSON output (suppress spinners and colors)").option("--skip-update-check", "Skip the automatic update check on startup");
 program.hook("preAction", async (thisCommand, actionCommand) => {

package/dist/{chunk-PR3IJAMV.js → chunk-NSG3PTR6.js}

@@ -8282,6 +8282,13 @@ var FLAG_REGISTRY = [
     defaultValue: false,
     envVar: "AGT_MODEL_API_ERROR_REPORTING_ENABLED"
   },
+  {
+    key: "claude-md-skills-index",
+    description: `Manager injects the "## Available Skills" bullet list (one line per installed skill, name + frontmatter description) into the agent's project CLAUDE.md. Claude Code already surfaces installed skills to the model natively from .claude/skills/*/SKILL.md, so on current models the list is duplicated context - and an expensive one: it measured 12,045 chars across 29 skills on a prod agent, pushing project/CLAUDE.md to 51k against Claude Code's 40,000-char ceiling, past which the tail of the agent's own system prompt is silently truncated. OFF suppresses ONLY the skill bullets; the "Updating Integrations" guidance in the same managed block is real instruction and is always kept. Defaults ON (today's behaviour) - flip OFF per org to reclaim the headroom.`,
+    flagType: "boolean",
+    defaultValue: true,
+    envVar: "AGT_CLAUDE_MD_SKILLS_INDEX_ENABLED"
+  },
   {
     key: "wedge-transient-notice",
     description: 'When a wedge-respawn was preceded by a transient LLM-API error (529/429/503/500 that exhausted its retries and wedged the turn), the manager writes the ENG-6058 give-up signal tagged reason=transient_overload so the channel sweeps post a friendly "I hit a brief overload \u2014 please resend" notice instead of leaving the user in silence (ENG-7360, extends ENG-6861 to the retry-exhaustion + wedge path). Boolean gate; ships dark \u2014 channel-visible copy soaks per host before going wide.',
@@ -10444,8 +10451,150 @@ var TurnOutcomeTracker = class {
   }
 };
 
+// src/lib/busy-bucket-ledger.ts
+var BUCKET_MS = 6e4;
+var MAX_ACCRUAL_SPAN_MS = 10 * 6e4;
+var MAX_RETAINED_BUCKETS = 240;
+var BILL_WHOLE_MINUTES = true;
+var MIN_BILLABLE_MS = 100;
+function bucketStartMs(atMs) {
+  return Math.floor(atMs / BUCKET_MS) * BUCKET_MS;
+}
+var BusyBucketLedger = class {
+  state = /* @__PURE__ */ new Map();
+  entry(codeName) {
+    let cur = this.state.get(codeName);
+    if (!cur) {
+      cur = { buckets: /* @__PURE__ */ new Map(), openSince: null };
+      this.state.set(codeName, cur);
+    }
+    return cur;
+  }
+  /**
+   * Credit occupancy for the span [fromMs, toMs), splitting it across every
+   * minute bucket it covers. Safe to call with any ordering — a reversed or
+   * zero-length span is a no-op rather than a negative credit.
+   */
+  accrueSpan(codeName, fromMs, toMs) {
+    if (!Number.isFinite(fromMs) || !Number.isFinite(toMs)) return;
+    if (toMs <= fromMs) return;
+    const start = Math.max(fromMs, toMs - MAX_ACCRUAL_SPAN_MS);
+    const led = this.entry(codeName);
+    for (let b = bucketStartMs(start); b < toMs; b += BUCKET_MS) {
+      const overlap = Math.min(toMs, b + BUCKET_MS) - Math.max(start, b);
+      if (overlap <= 0) continue;
+      const prev = led.buckets.get(b) ?? 0;
+      led.buckets.set(b, Math.min(BUCKET_MS, prev + overlap));
+    }
+    this.evict(led);
+  }
+  /** The agent started doing work. Idempotent while already occupied. */
+  open(codeName, atMs) {
+    const led = this.entry(codeName);
+    if (led.openSince == null) led.openSince = atMs;
+  }
+  /**
+   * Accrue everything owed up to `nowMs` WITHOUT ending the occupancy. This is
+   * what makes a long turn fill every bucket it spans: each probe pass ticks,
+   * banking the elapsed slice and moving the watermark forward.
+   */
+  tick(codeName, nowMs) {
+    const led = this.state.get(codeName);
+    if (!led || led.openSince == null) return;
+    if (nowMs <= led.openSince) return;
+    this.accrueSpan(codeName, led.openSince, nowMs);
+    led.openSince = nowMs;
+  }
+  /** The agent stopped doing work. Banks the final slice. */
+  close(codeName, atMs) {
+    const led = this.state.get(codeName);
+    if (!led || led.openSince == null) return;
+    this.accrueSpan(codeName, led.openSince, atMs);
+    led.openSince = null;
+  }
+  /**
+   * Take every CLOSED bucket for reporting, removing it from the ledger.
+   *
+   * Only closed buckets — a bucket whose minute has not yet elapsed is still
+   * accruing, and reporting it early would send a partial value that the next
+   * drain would have to correct. The open bucket stays and is drained once it
+   * closes.
+   *
+   * DESTRUCTIVE, deliberately: this is the same read-and-reset contract as the
+   * watchdog give-up counters, and it carries the same obligation — the caller
+   * MUST `credit()` the result back if the POST fails, or a transient 5xx
+   * permanently deletes billable occupancy that cannot be reconstructed.
+   */
+  drainClosed(codeName, nowMs) {
+    const led = this.state.get(codeName);
+    if (!led) return [];
+    this.tick(codeName, nowMs);
+    const openBucket = bucketStartMs(nowMs);
+    const out = [];
+    for (const [b, ms] of [...led.buckets].sort((x, y) => x[0] - y[0])) {
+      if (b >= openBucket) continue;
+      led.buckets.delete(b);
+      if (ms < MIN_BILLABLE_MS) continue;
+      const seconds = BILL_WHOLE_MINUTES ? 60 : Math.min(60, Math.ceil(ms / 1e3));
+      out.push({ bucket: new Date(b).toISOString(), seconds });
+    }
+    return out;
+  }
+  /**
+   * Put drained buckets back after a failed POST. Merges rather than replaces,
+   * so occupancy accrued since the drain is preserved.
+   */
+  credit(codeName, buckets) {
+    if (buckets.length === 0) return;
+    const led = this.entry(codeName);
+    for (const b of buckets) {
+      const at = Date.parse(b.bucket);
+      if (!Number.isFinite(at)) continue;
+      const key = bucketStartMs(at);
+      const prev = led.buckets.get(key) ?? 0;
+      led.buckets.set(key, Math.min(BUCKET_MS, prev + b.seconds * 1e3));
+    }
+    this.evict(led);
+  }
+  /** Agents currently holding reportable state. */
+  trackedAgents() {
+    return [...this.state.keys()];
+  }
+  /**
+   * Drop everything for an agent. Called from the same teardown that resets
+   * turn health, so a fresh session is not born holding the dead one's
+   * occupancy.
+   */
+  reset(codeName) {
+    this.state.delete(codeName);
+  }
+  evict(led) {
+    if (led.buckets.size <= MAX_RETAINED_BUCKETS) return;
+    const ordered = [...led.buckets.keys()].sort((a, b) => a - b);
+    for (const k of ordered.slice(0, led.buckets.size - MAX_RETAINED_BUCKETS)) {
+      led.buckets.delete(k);
+    }
+  }
+};
+var sharedBusyBuckets = new BusyBucketLedger();
+
 // src/lib/opencode-activity-tracker.ts
 var OpencodeActivityTracker = class {
+  /**
+   * ENG-8116: the same lifecycle also drives the duration ledger. opencode is
+   * the runtime that can measure occupancy EXACTLY — beginTurn/endTurn bracket
+   * real work — so the spans go straight in rather than being inferred from a
+   * file mtime the way Claude Code's have to be.
+   *
+   * Kept inside this class deliberately, rather than having callers poke both:
+   * the lifecycle discipline that makes occupancy correct (the `finally`, the
+   * live-session guard) already lives at one call site, and a second one to
+   * keep in sync is exactly how a leaked in-flight count would bill an idle
+   * agent around the clock.
+   */
+  constructor(ledger = sharedBusyBuckets) {
+    this.ledger = ledger;
+  }
   state = /* @__PURE__ */ new Map();
   entry(codeName) {
     let cur = this.state.get(codeName);
@@ -10456,8 +10605,9 @@ var OpencodeActivityTracker = class {
     return cur;
   }
   /** A turn has been dispatched to the serve. Call BEFORE awaiting it. */
-  beginTurn(codeName) {
+  beginTurn(codeName, now = Date.now()) {
     this.entry(codeName).inFlight += 1;
+    this.ledger.open(codeName, now);
   }
   /**
    * A dispatched turn has resolved. Call in a `finally`, so a throw cannot
@@ -10471,6 +10621,7 @@ var OpencodeActivityTracker = class {
     const cur = this.entry(codeName);
     cur.inFlight = Math.max(0, cur.inFlight - 1);
     if (counted) cur.lastActiveAt = now;
+    if (cur.inFlight === 0) this.ledger.close(codeName, now);
   }
   /**
    * Seconds since this agent was last doing work, or null if it never has been
@@ -10494,6 +10645,7 @@ var OpencodeActivityTracker = class {
    */
   reset(codeName) {
     this.state.delete(codeName);
+    this.ledger.reset(codeName);
   }
 };
 
@@ -12768,6 +12920,7 @@ export {
   sha256,
   hashFile,
   execFilePromiseLong,
+  sharedBusyBuckets,
   readProvisionedOpencodeModel,
   startOpencodeSession,
   readOpencodePaneLogTail,
@@ -12825,4 +12978,4 @@ export {
   stopAllSessionsAndWait,
   getProjectDir
 };
-//# sourceMappingURL=chunk-PR3IJAMV.js.map
+//# sourceMappingURL=chunk-NSG3PTR6.js.map