@integrity-labs/agt-cli 0.28.424 → 0.28.426

package/dist/bin/agt.js

@@ -40,7 +40,7 @@ import {
   success,
   table,
   warn
-} from "../chunk-2QBY2QVX.js";
+} from "../chunk-XDODHW3I.js";
 import {
   AnchorSessionClient,
   CHANNEL_REGISTRY,
@@ -70,7 +70,7 @@ import {
   renderTemplate,
   resolveChannels,
   serializeManifestForSlackCli
-} from "../chunk-CWIWI2ZX.js";
+} from "../chunk-HXP4I5QZ.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.424" : "dev";
+var cliVersion = true ? "0.28.426" : "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.424" : "dev";
+var cliVersion2 = true ? "0.28.426" : "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-CWIWI2ZX.js → chunk-HXP4I5QZ.js}

@@ -5902,6 +5902,86 @@ var INTEGRATION_REGISTRY = [
       ]
     }
   },
+  {
+    // Social Scraping: a PREMIUM, platform-managed integration on the Deck /
+    // Firecrawl / X-Search model (ADR-0031, epic ENG-6920; ADR-0053). Backed by
+    // Apify, but deliberately NOT surfaced as an "Apify" integration - the
+    // integration is what a customer picks, and Apify is a vendor, not a job.
+    // Splitting by job also means opt-in, rate card and monthly budget are keyed
+    // per definition, so an org can take Local Business Data without taking the
+    // pricier, more ToS-sensitive social scraping.
+    //
+    // Augmented holds ONE Apify account whose token (APIFY_API_TOKEN, read
+    // from SSM - the API Lambda env is at the 4KB cap) every customer run bills
+    // back to, so the key is a single platform-held secret, NOT a per-agent
+    // credential. Auth type is `none` - customers never enter a key. Tools run on
+    // a brokered-REST lane (apify-brokers.ts) so each run is metered at one
+    // chokepoint and gated on a per-org monthly USD cap + the per-org premium
+    // opt-in.
+    //
+    // "PPE-only" is guaranteed by a curated allowlist: the broker only ever runs
+    // Actors on it, so a rental / pay-per-usage Actor can never surprise-bill the
+    // shared account. (Apify's x402 rail enforces PPE-only at the payment layer;
+    // we are on the account-key rail - Option A in the spike.) See
+    // docs/design/apify-premium-option-a-ppe-allowlist.md.
+    //
+    // No `installable` here on purpose: this is a seed integration
+    // (integration-definitions.json), so the seed catalog already makes it
+    // picker-visible. This registry entry exists ONLY to carry the `premium`
+    // descriptor that `isPremiumDefinition` reads - which arms the per-org opt-in
+    // gate, the priced acknowledgement modal, and the admin pricing tab.
+    id: "social-scraping",
+    name: "Social Scraping",
+    category: "social",
+    description: "Pull public posts and videos from TikTok, Instagram and YouTube - captions, media, engagement counts and URLs - for brand, competitor and campaign research. Augmented Team manages the scraping account for you; there is no key to enter.",
+    supported_auth_types: ["none"],
+    capabilities: [
+      { id: "social-scraping:scrape", name: "Scrape Social Posts", description: "Scrape public TikTok, Instagram and YouTube content (social_scrape_tiktok, social_scrape_instagram, social_scrape_youtube).", access: "write" },
+      { id: "social-scraping:status", name: "Check Scrape Runs", description: "Poll a running scrape for status + results (social_scrape_status).", access: "read" }
+    ],
+    docs_url: "https://docs.apify.com/api/v2",
+    beta: true,
+    // Premium (billable). The upstream pay-per-event cost is per-Actor and
+    // VARIABLE (each Actor's creator sets its own event prices), unlike X-Search's
+    // fixed per-post price. So we meter the ACTUAL cost charged to us for each
+    // run, as a pass-through: `units` = the run's `usageTotalUsd` in whole US
+    // cents (the physical unit `usd_cent`), and the rate card prices each cent at
+    // a managed markup (1.5x USD). This keeps margin safe across cheap and
+    // expensive scrapes alike. `event_type` must match what the broker writes to
+    // integration_usage_events. Until the rate row is seeded a run prices at 0
+    // (budget gate inert) - the rate-card migration ships in the same PR.
+    premium: {
+      pricing: "usage",
+      note: "Billed per result on the upstream pay-per-event cost of each scrape, at a managed markup.",
+      meters: [{ event_type: "actor_run", unit: "usd_cent" }]
+    }
+  },
+  {
+    // Local Business Data: the second Apify-backed premium integration (ADR-0053).
+    // Same platform-held account, same pass-through metering model, but a separate
+    // definition so its opt-in, rate card and monthly budget are independent of
+    // Social Scraping's - see the note on that entry for why the split exists.
+    //
+    // Distinct from Firecrawl on purpose: Firecrawl covers generic web
+    // scrape/crawl/search, and we deliberately do NOT ship an Apify-backed
+    // duplicate of that. This is the local-places job Firecrawl does not do.
+    id: "local-business-data",
+    name: "Local Business Data",
+    category: "knowledge",
+    description: "Find local businesses on Google Maps and pull their public listing details - name, address, phone, website, category, rating and review count - for local market research, competitor lists and lead research. Augmented Team manages the data account for you; there is no key to enter.",
+    supported_auth_types: ["none"],
+    capabilities: [
+      { id: "local-business-data:search", name: "Search Local Businesses", description: "Search Google Maps for businesses and return their public listing details (local_business_search).", access: "write" },
+      { id: "local-business-data:status", name: "Check Searches", description: "Poll a running search for status + results (local_business_search_status).", access: "read" }
+    ],
+    docs_url: "https://docs.apify.com/api/v2",
+    beta: true,
+    premium: {
+      pricing: "usage",
+      note: "Billed per place returned on the upstream pay-per-event cost of each search, at a managed markup.",
+      meters: [{ event_type: "actor_run", unit: "usd_cent" }]
+    }
+  },
   {
     // Seed-catalog toolkit (composed by the ultimate-app-coder bundle). Registered
     // here only so the manager's ensureToolkitCli installs the binary via the
@@ -10364,8 +10444,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);
@@ -10376,8 +10598,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
@@ -10391,6 +10614,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
@@ -10414,6 +10638,7 @@ var OpencodeActivityTracker = class {
    */
   reset(codeName) {
     this.state.delete(codeName);
+    this.ledger.reset(codeName);
   }
 };
 
@@ -12688,6 +12913,7 @@ export {
   sha256,
   hashFile,
   execFilePromiseLong,
+  sharedBusyBuckets,
   readProvisionedOpencodeModel,
   startOpencodeSession,
   readOpencodePaneLogTail,
@@ -12745,4 +12971,4 @@ export {
   stopAllSessionsAndWait,
   getProjectDir
 };
-//# sourceMappingURL=chunk-CWIWI2ZX.js.map
+//# sourceMappingURL=chunk-HXP4I5QZ.js.map