parawatch 0.1.0 → 0.2.0

package/dist/core/ops.js

@@ -1,8 +1,8 @@
 import fs from "node:fs";
 import path from "node:path";
-import { appendEvent, eventsPath, readCursor, readEvents, writeCursor } from "./store.js";
+import { appendEvent, eventsPath, homeDir, readCursor, readEvents, writeCursor } from "./store.js";
 import { fold, nextId } from "./state.js";
-import { CARD_KINDS, HUMAN } from "./types.js";
+import { CARD_KINDS, HUMAN, PR_CHANGES } from "./types.js";
 export class UserError extends Error {
 }
 function cleanList(xs) {
@@ -27,6 +27,19 @@ export function removeProject(name) {
         throw new UserError(`no project named "${name}"`);
     appendEvent(() => ({ type: "project.remove", name }));
 }
+const PREVIEW_MAX = 20_000;
+function readPreview(file) {
+    if (!file?.trim())
+        return undefined;
+    let text;
+    try {
+        text = fs.readFileSync(path.resolve(file), "utf8");
+    }
+    catch {
+        throw new UserError(`cannot read the preview file ${file}`);
+    }
+    return text.length > PREVIEW_MAX ? text.slice(0, PREVIEW_MAX) + "\n…" : text;
+}
 /** A date or timestamp as ISO text; a bare date counts as local midnight. */
 export function parseWhen(s) {
     const t = s.trim();
@@ -52,7 +65,10 @@ export function openCard(input) {
         throw new UserError("a card needs a title");
     if (!input.project.trim())
         throw new UserError("a card needs --project");
-    const options = cleanList(input.options);
+    const action = input.action?.trim() || undefined;
+    // an approval with no choices of its own is a yes or a no
+    const options = cleanList(input.options) ?? (action ? ["Do it", "Don't"] : undefined);
+    const preview = readPreview(input.preview);
     if (input.recommend !== undefined) {
         if (!options)
             throw new UserError("--recommend needs --option");
@@ -84,6 +100,8 @@ export function openCard(input) {
                 from,
                 session,
                 since,
+                action,
+                preview,
             },
         };
     });
@@ -160,10 +178,13 @@ export function closeCard(id, note) {
     appendEvent(() => ({ type: "card.close", card: id, note: note?.trim() || undefined }));
 }
 export function startRun(r) {
+    if (r.heartbeat !== undefined && (!Number.isFinite(r.heartbeat) || r.heartbeat <= 0))
+        throw new UserError("--heartbeat must be a number of seconds above 0");
+    const log = r.log?.trim() ? path.resolve(r.log) : undefined;
     let id = "";
     appendEvent((events) => {
         id = nextId(events, "r");
-        return { type: "run.start", run: { id, project: r.project, task: r.task, title: r.title, parent: r.parent } };
+        return { type: "run.start", run: { id, project: r.project, task: r.task, title: r.title, parent: r.parent, heartbeat: r.heartbeat, log } };
     });
     return id;
 }
@@ -172,23 +193,82 @@ export function noteRun(id, text) {
         throw new UserError(`no declared run "${id}"`);
     appendEvent(() => ({ type: "run.note", run: id, text }));
 }
+export function beatRun(id) {
+    if (!fold(readEvents()).runs.has(id))
+        throw new UserError(`no declared run "${id}"`);
+    appendEvent(() => ({ type: "run.beat", run: id }));
+}
 export function endRun(id, status, note) {
     if (!fold(readEvents()).runs.has(id))
         throw new UserError(`no declared run "${id}"`);
     appendEvent(() => ({ type: "run.end", run: id, status, note }));
 }
-export function claimSession(claim) {
-    if (claim.session.length < 6)
+/**
+ * Say which project and task a session works on. A claim without a project keeps the session's
+ * earlier claim and only changes what is given (for `--done`). A claim of a new task clears `done`.
+ */
+export function claimSession(input) {
+    if (input.session.length < 6)
         throw new UserError("give at least 6 characters of the session id");
+    const before = fold(readEvents()).claims.find((c) => c.session === input.session);
+    const project = input.project?.trim() || before?.project;
+    if (!project)
+        throw new UserError("this session has not claimed a project yet: give --project");
+    const sameWork = !input.project || (input.project === before?.project && (input.task ?? before?.task) === before?.task);
+    const claim = {
+        session: input.session,
+        project,
+        task: input.task ?? (sameWork ? before?.task : undefined),
+        role: input.role ?? before?.role,
+        title: input.title ?? before?.title,
+        kind: input.kind ?? before?.kind,
+        // any new claim means work goes on; only --done marks it finished
+        done: input.done?.trim() || undefined,
+    };
+    for (const k of Object.keys(claim))
+        if (claim[k] === undefined)
+            delete claim[k];
     appendEvent(() => ({ type: "run.claim", claim }));
+    return claim;
+}
+// ---------------------------------------------------------------- pull requests
+export function linkPr(link) {
+    const claims = fold(readEvents()).claims;
+    const claim = link.session ? claims.find((c) => link.session.startsWith(c.session)) : undefined;
+    const project = link.project?.trim() || claim?.project;
+    appendEvent(() => ({
+        type: "pr.link",
+        link: { pr: link.pr, session: link.session, project, task: link.task?.trim() || claim?.task },
+    }));
+}
+export function unlinkPr(key) {
+    if (!fold(readEvents()).prLinks.has(key))
+        throw new UserError(`no linked pull request ${key}`);
+    appendEvent(() => ({ type: "pr.unlink", pr: key }));
 }
-/** Human answers and comments newer than `afterSeq`, on cards that are not closed. */
+/** Something another tool saw on a PR (a merge bot, a ticket system), recorded like GitHub's own. */
+export function prEvent(pr, change, opts = {}) {
+    if (!PR_CHANGES.includes(change))
+        throw new UserError(`change must be one of ${PR_CHANGES.join(", ")}`);
+    appendEvent(() => ({ type: "pr.change", pr, change: change, by: opts.by, text: opts.text?.trim() || undefined, title: opts.title, source: "external" }));
+}
+/**
+ * Human answers and comments newer than `afterSeq`, on cards that are not closed, and news on pull
+ * requests linked to the project.
+ */
 export function inboxFrom(events, afterSeq, filter) {
     const state = fold(events);
     const out = [];
     for (const ev of events) {
         if (ev.seq <= afterSeq)
             continue;
+        if (ev.type === "pr.change") {
+            const link = state.prLinks.get(ev.pr.key);
+            if (!link || filter.card || (filter.project && link.project !== filter.project))
+                continue;
+            out.push({ seq: ev.seq, at: ev.ts, kind: "pr", by: ev.by ?? ev.source, pr: { ref: ev.pr, change: ev.change, title: ev.title, text: ev.text, project: link.project } });
+            continue;
+        }
         if (ev.type !== "card.answer" && ev.type !== "card.comment")
             continue;
         if (ev.by !== HUMAN)
@@ -219,6 +299,70 @@ export function inboxFrom(events, afterSeq, filter) {
     }
     return out;
 }
+// ---------------------------------------------------------------- listeners
+function listenersDir() {
+    return path.join(homeDir(), "listeners");
+}
+/** Mark this process as waiting, so cards can say whether an answer reaches an agent at once. */
+export function startListening(l) {
+    const file = path.join(listenersDir(), `${process.pid}.json`);
+    fs.mkdirSync(listenersDir(), { recursive: true });
+    const me = { ...l, pid: process.pid, since: new Date().toISOString() };
+    fs.writeFileSync(file, JSON.stringify(me) + "\n");
+    let done = false;
+    const stop = () => {
+        if (done)
+            return;
+        done = true;
+        fs.rmSync(file, { force: true });
+    };
+    process.once("exit", stop);
+    for (const sig of ["SIGINT", "SIGTERM", "SIGHUP"]) {
+        process.once(sig, () => {
+            stop();
+            process.exit(128 + (sig === "SIGINT" ? 2 : sig === "SIGTERM" ? 15 : 1));
+        });
+    }
+    return stop;
+}
+function alive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        return err.code === "EPERM";
+    }
+}
+/** Waits running now. Files left by a process that died are removed. */
+export function listeners() {
+    let names;
+    try {
+        names = fs.readdirSync(listenersDir()).filter((f) => f.endsWith(".json"));
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const n of names) {
+        const file = path.join(listenersDir(), n);
+        try {
+            const l = JSON.parse(fs.readFileSync(file, "utf8"));
+            if (alive(l.pid))
+                out.push(l);
+            else
+                fs.rmSync(file, { force: true });
+        }
+        catch {
+            // half written; read it next time
+        }
+    }
+    return out;
+}
+/** The waits an answer to this card would wake right now. */
+export function listenersFor(card, ls) {
+    return ls.filter((l) => (l.card ? l.card === card.id : !l.project || l.project === card.project));
+}
 export function consumerName(opts) {
     return opts.as || opts.project || (opts.card ? `card-${opts.card}` : "default");
 }

package/dist/core/runs.js

@@ -1,4 +1,5 @@
 import { execFileSync } from "node:child_process";
+import fs from "node:fs";
 import path from "node:path";
 import { scanAll } from "../adapters/index.js";
 import { ACTIVITY_MINUTES, activeMinutes } from "../adapters/jsonl.js";
@@ -64,24 +65,70 @@ function projectForPrompt(prompt, ms) {
     }
     return hits.size === 1 ? [...hits][0] : undefined;
 }
+/** The project most of these folders belong to (ties go to the most recent), with its count. */
+function projectForEdits(dirs, ms) {
+    const counts = new Map();
+    for (const d of dirs ?? []) {
+        const p = projectForCwd(d, ms);
+        if (p)
+            counts.set(p, (counts.get(p) ?? 0) + 1);
+    }
+    return counts;
+}
+function topOf(counts, dirs, ms) {
+    let best;
+    let n = 0;
+    // walk newest first so a tie goes to where the run worked last
+    for (const d of [...(dirs ?? [])].reverse()) {
+        const p = projectForCwd(d, ms);
+        if (p && (counts.get(p) ?? 0) > n) {
+            best = p;
+            n = counts.get(p);
+        }
+    }
+    return best;
+}
+function claimFor(id, state) {
+    return state.claims.find((c) => id.startsWith(c.session));
+}
 /**
- * Give each observed run a project, in this order: an explicit claim, the checkout
- * it runs in, its parent's project, a project path named in its first prompt.
+ * Give each observed run a project, in this order: an explicit claim; the checkout it runs in,
+ * unless it only edits files of another project; its parent's project; the project whose files it
+ * edits most; a project path named in its first prompt.
  */
 export function attribute(runs, state) {
     const ms = matchers([...state.projects.values()]);
     const byId = new Map(runs.map((r) => [r.id, r]));
     for (const r of runs) {
-        const claim = state.claims.find((c) => r.id.startsWith(c.session));
+        const claim = claimFor(r.id, state);
         if (claim) {
             r.project = claim.project;
+            r.projectSource = "claim";
             r.task = claim.task ?? r.task;
             r.role = claim.role ?? r.role;
             if (claim.title)
                 r.title = claim.title;
+            if (claim.kind === "scheduled")
+                r.scheduled = true;
+            // done until someone writes to the session again
+            if (claim.done && claim.at && (!r.lastPromptAt || r.lastPromptAt < claim.at)) {
+                r.done = claim.done;
+                if (r.state === "idle")
+                    r.state = "done";
+                r.asks = undefined;
+            }
             continue;
         }
-        r.project = projectForCwd(r.cwd, ms);
+        const here = projectForCwd(r.cwd, ms);
+        const edits = projectForEdits(r.touched, ms);
+        if (here && !r.parent && edits.size && !edits.has(here)) {
+            r.project = topOf(edits, r.touched, ms);
+            r.projectSource = "edits";
+        }
+        else if (here) {
+            r.project = here;
+            r.projectSource = "cwd";
+        }
     }
     // parents may themselves get a project only from a claim, so resolve children afterwards
     for (let pass = 0; pass < 3; pass++) {
@@ -89,18 +136,73 @@ export function attribute(runs, state) {
             if (r.project || !r.parent)
                 continue;
             const p = byId.get(r.parent);
-            if (p?.project)
-                r.project = p.project;
-            else
-                r.project = state.claims.find((c) => r.parent.startsWith(c.session))?.project;
+            const project = p?.project ?? claimFor(r.parent, state)?.project;
+            if (project) {
+                r.project = project;
+                r.projectSource = "parent";
+            }
         }
     }
     for (const r of runs) {
-        if (!r.project)
-            r.project = projectForPrompt(r.prompt, ms);
+        if (r.project)
+            continue;
+        const edits = topOf(projectForEdits(r.touched, ms), r.touched, ms);
+        const prompt = edits ? undefined : projectForPrompt(r.prompt, ms);
+        r.project = edits ?? prompt;
+        if (r.project)
+            r.projectSource = edits ? "edits" : "prompt";
     }
     return runs;
 }
+/**
+ * Fold repeated runs of a scheduled task into the newest one, with a count. Runs claimed as
+ * scheduled group by project and task; unclaimed top-level sessions group by an identical first
+ * prompt. A run still working is never folded away.
+ */
+export function foldRepeats(runs) {
+    const groups = new Map();
+    for (const r of runs) {
+        if (r.kind !== "session" || r.parent)
+            continue;
+        const key = r.scheduled ? `s:${r.project}:${r.task ?? r.title}` : r.projectSource === "claim" || !r.prompt ? undefined : `p:${r.prompt}`;
+        if (!key)
+            continue;
+        if (!groups.has(key))
+            groups.set(key, []);
+        groups.get(key).push(r);
+    }
+    const drop = new Set();
+    for (const g of groups.values()) {
+        if (g.length < 2)
+            continue;
+        g.sort((a, b) => (b.lastActivity ?? "").localeCompare(a.lastActivity ?? ""));
+        const [newest, ...older] = g;
+        let n = 0;
+        for (const r of older) {
+            if (r.state === "working" || r.state === "waiting" || r.asks)
+                continue;
+            drop.add(r);
+            n++;
+        }
+        if (n) {
+            newest.repeats = n;
+            newest.scheduled = true;
+        }
+    }
+    // children of a folded run go with it
+    const gone = new Set([...drop].map((r) => r.id));
+    return runs.filter((r) => !drop.has(r) && !(r.parent && gone.has(r.parent)));
+}
+/** Linked pull requests, put on the run that owns them. */
+function attachPrs(runs, state) {
+    for (const link of state.prLinks.values()) {
+        if (!link.session)
+            continue;
+        const r = runs.find((x) => x.id.startsWith(link.session));
+        if (r)
+            (r.prs ??= []).push(link.pr.key);
+    }
+}
 /** A declared run is busy from its start until it ends (or now, while it runs). */
 function declaredActivity(start, end, now) {
     const from = Date.parse(start);
@@ -112,21 +214,38 @@ function declaredActivity(start, end, now) {
         times.push(to);
     return activeMinutes(times, now);
 }
+/** When a declared run last showed life: its last beat or note, or its log file changing. */
+function lastSign(d) {
+    if (!d.log)
+        return d.lastActivity;
+    try {
+        const m = new Date(fs.statSync(d.log).mtimeMs).toISOString();
+        return m > d.lastActivity ? m : d.lastActivity;
+    }
+    catch {
+        return d.lastActivity;
+    }
+}
 export function declaredRuns(state, now = Date.now()) {
-    return [...state.runs.values()].map((d) => ({
-        id: d.id,
-        runtime: "declared",
-        kind: "declared",
-        title: d.title,
-        project: d.project,
-        task: d.task,
-        parent: d.parent,
-        startedAt: d.startedAt,
-        lastActivity: d.lastActivity,
-        state: d.status === "running" ? "working" : d.status,
-        action: d.note,
-        activity: declaredActivity(d.startedAt, d.status === "running" ? undefined : (d.endedAt ?? d.lastActivity), now),
-    }));
+    return [...state.runs.values()].map((d) => {
+        const last = d.status === "running" ? lastSign(d) : d.lastActivity;
+        const quiet = d.status === "running" && d.heartbeat !== undefined && now - Date.parse(last) > d.heartbeat * 1000;
+        return {
+            id: d.id,
+            runtime: "declared",
+            kind: "declared",
+            title: d.title,
+            project: d.project,
+            task: d.task,
+            parent: d.parent,
+            startedAt: d.startedAt,
+            lastActivity: last,
+            state: quiet ? "stalled" : d.status === "running" ? "working" : d.status,
+            action: quiet ? `no sign of life for ${Math.round((now - Date.parse(last)) / 60_000)}m${d.note ? ` · ${d.note}` : ""}` : d.note,
+            projectSource: "claim",
+            activity: declaredActivity(d.startedAt, d.status === "running" ? undefined : (d.endedAt ?? d.lastActivity), now),
+        };
+    });
 }
 const ENDED = new Set(["done", "idle", "failed"]);
 const RECENT_END_MS = 30 * 60_000;
@@ -137,6 +256,7 @@ export function collectRuns(state, q, now = Date.now()) {
     const recent = (r) => !r.lastActivity || Date.parse(r.lastActivity) >= sinceMs;
     let runs = attribute(scanAll({ sinceMs, now }, q.runtimes), state).filter(recent);
     runs.push(...declaredRuns(state, now).filter(recent));
+    attachPrs(runs, state);
     if (q.project)
         runs = runs.filter((r) => r.project === q.project);
     if (!q.includeEnded) {
@@ -148,6 +268,8 @@ export function collectRuns(state, q, now = Date.now()) {
                 return r.lastActivity ? now - Date.parse(r.lastActivity) < OLD_STALL_MS : true;
             if (!ENDED.has(r.state))
                 return true;
+            if (r.asks)
+                return true; // still waiting for the human to read it
             if (live.has(r.id))
                 return true;
             if (r.role === "lead")
@@ -155,6 +277,8 @@ export function collectRuns(state, q, now = Date.now()) {
             return r.lastActivity ? now - Date.parse(r.lastActivity) < RECENT_END_MS : false;
         });
     }
+    if (!q.keepRepeats)
+        runs = foldRepeats(runs);
     return runs.sort((a, b) => (b.lastActivity ?? "").localeCompare(a.lastActivity ?? ""));
 }
 //# sourceMappingURL=runs.js.map

package/dist/core/snapshot.js

@@ -1,3 +1,5 @@
+import { prViews, keyOf, parsePrRef, readCache, githubConfig } from "./github.js";
+import { linkPr, listeners } from "./ops.js";
 import { collectRuns } from "./runs.js";
 import { fold } from "./state.js";
 import { readEvents } from "./store.js";
@@ -5,13 +7,58 @@ import { SCHEMA_VERSION } from "./types.js";
 /**
  * `closed`: also carry the most recently closed cards, newest first, so a panel can show them
  * again. Off by default; open and answered cards are always there.
+ *
+ * GitHub is read from the last reading only; `syncGithub` refreshes it.
  */
 export function snapshot(opts = {}) {
-    const state = fold(readEvents());
+    let state = fold(readEvents());
+    const runs = collectRuns(state, { sinceHours: opts.sinceHours ?? 6, project: opts.project, keepRepeats: opts.keepRepeats });
+    if (linkCreatedPrs(runs, state))
+        state = fold(readEvents());
     const all = [...state.cards.values()].filter((c) => !opts.project || c.project === opts.project);
     const cards = [...all.filter((c) => c.status !== "closed"), ...recentlyClosed(all, opts.closed ?? 0)];
-    const runs = collectRuns(state, { sinceHours: opts.sinceHours ?? 6, project: opts.project });
-    return { v: SCHEMA_VERSION, generatedAt: new Date().toISOString(), projects: [...state.projects.values()], cards, runs };
+    quietAnsweredAsks(runs, all);
+    const cache = readCache();
+    const enabled = githubConfig().enabled && (cache.hosts === undefined ? false : cache.hosts.length > 0);
+    let prs = enabled ? prViews(cache, state, runs) : undefined;
+    if (prs && opts.project)
+        prs = prs.filter((p) => p.project === opts.project);
+    return {
+        v: SCHEMA_VERSION,
+        generatedAt: new Date().toISOString(),
+        projects: [...state.projects.values()],
+        cards,
+        runs,
+        prs,
+        github: { enabled, fetchedAt: cache.fetchedAt, error: cache.error },
+        listeners: listeners(),
+    };
+}
+/** A pull request a session's log shows it opened belongs to that session, unless linked already. */
+function linkCreatedPrs(runs, state) {
+    let added = false;
+    for (const r of runs) {
+        for (const url of r.createdPrs ?? []) {
+            const key = keyOf(url);
+            const pr = parsePrRef(url);
+            if (!key || !pr || state.prLinks.has(key))
+                continue;
+            linkPr({ pr, session: r.id, project: r.project, task: r.task });
+            state.prLinks.set(key, { pr, session: r.id, project: r.project, at: new Date().toISOString() });
+            added = true;
+        }
+    }
+    return added;
+}
+/** A question asked in chat is no longer pending once the session put it on a card. */
+function quietAnsweredAsks(runs, cards) {
+    for (const r of runs) {
+        if (!r.asks)
+            continue;
+        const turn = r.lastPromptAt ?? "";
+        if (cards.some((c) => c.status !== "closed" && c.session && r.id.startsWith(c.session) && c.openedAt >= turn))
+            r.asks = undefined;
+    }
 }
 export function recentlyClosed(cards, keep) {
     if (keep <= 0)

package/dist/core/state.js

@@ -1,6 +1,6 @@
 /** Rebuild current state from the event log. */
 export function fold(events) {
-    const s = { projects: new Map(), cards: new Map(), runs: new Map(), claims: [], lastSeq: 0 };
+    const s = { projects: new Map(), cards: new Map(), runs: new Map(), claims: [], prLinks: new Map(), lastSeq: 0 };
     for (const ev of events) {
         s.lastSeq = Math.max(s.lastSeq, ev.seq);
         switch (ev.type) {
@@ -61,6 +61,12 @@ export function fold(events) {
                 r.lastActivity = ev.ts;
                 break;
             }
+            case "run.beat": {
+                const r = s.runs.get(ev.run);
+                if (r)
+                    r.lastActivity = ev.ts;
+                break;
+            }
             case "run.end": {
                 const r = s.runs.get(ev.run);
                 if (!r)
@@ -75,7 +81,13 @@ export function fold(events) {
             case "run.claim":
                 // a later claim of the same session replaces the earlier one
                 s.claims = s.claims.filter((c) => c.session !== ev.claim.session);
-                s.claims.push(ev.claim);
+                s.claims.push({ ...ev.claim, at: ev.ts });
+                break;
+            case "pr.link":
+                s.prLinks.set(ev.link.pr.key, { ...ev.link, at: ev.ts });
+                break;
+            case "pr.unlink":
+                s.prLinks.delete(ev.pr);
                 break;
         }
     }

package/dist/core/store.js

@@ -90,18 +90,17 @@ export function parseEventLines(text) {
 }
 /** Append one event. `build` sees the current events so it can pick ids under the lock. */
 export function appendEvent(build) {
-    return withLock(() => {
-        const events = readEvents();
-        const last = events[events.length - 1];
-        const ev = {
-            v: SCHEMA_VERSION,
-            seq: (last?.seq ?? 0) + 1,
-            ts: new Date().toISOString(),
-            ...build(events),
-        };
-        fs.appendFileSync(eventsPath(), JSON.stringify(ev) + "\n");
-        return ev;
-    });
+    return withLock(() => appendLocked((events) => [build(events)])[0]);
+}
+/** Append events while already holding the lock (inside `withLock`). */
+export function appendLocked(build) {
+    const events = readEvents();
+    let seq = events[events.length - 1]?.seq ?? 0;
+    const ts = new Date().toISOString();
+    const out = build(events).map((body) => ({ v: SCHEMA_VERSION, seq: ++seq, ts, ...body }));
+    if (out.length)
+        fs.appendFileSync(eventsPath(), out.map((e) => JSON.stringify(e) + "\n").join(""));
+    return out;
 }
 const CURSOR_NAME = /^[A-Za-z0-9._-]+$/;
 function cursorPath(name) {

package/dist/core/types.js

@@ -1,5 +1,6 @@
 export const SCHEMA_VERSION = 1;
 export const CARD_KINDS = ["decide", "try", "block", "todo"];
+export const PR_CHANGES = ["review", "approved", "changes_requested", "commented", "ci_failed", "ci_passed", "queued", "queue_removed", "conflict", "merged", "closed", "note"];
 /** Who counts as a human when deciding what wakes an agent. */
 export const HUMAN = "human";
 //# sourceMappingURL=types.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "parawatch",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "A control tower for people running many AI coding agents in parallel: see what is running, what needs you, and wake the right agent when you answer.",
   "keywords": [
     "ai-agents",