@adecore/agents 0.0.1 → 0.17.0-beta.2

package/src/providers/registry.ts

@@ -0,0 +1,150 @@
+import type { AgentKind, ProviderCapabilities, ProviderInfo } from '@adecore/agent-contracts';
+import { ModelCatalog } from './catalog.ts';
+import { claudeProvider } from './claude-provider.ts';
+import { codexProvider } from './codex-provider.ts';
+import type { CliDetection } from './detect.ts';
+import type { ChatProvider } from './provider.ts';
+
+// How long a "is it installed" answer stays good; an install mid-session shows up on the next check.
+const DETECTION_TTL_MS = 60_000;
+
+const DISABLED: CliDetection = { installed: false, version: 'Disabled in Settings' };
+
+const NO_CAPABILITIES: ProviderCapabilities = {
+    chat: false,
+    terminal: false,
+    hooks: false,
+    streamsToolOutput: false,
+    diffs: 'none',
+    attachments: false,
+    mentions: false,
+    denyReason: false,
+    allowAlways: false,
+    asyncQuestions: false,
+    compaction: 'none',
+    reportsCost: false,
+    reportsContextWindow: false,
+    reportsThinking: false,
+    slashCommands: false
+};
+
+/* A CLI of a kind the host does not offer: a record or an account may still name one, and it starts nothing. */
+export function unofferedProvider(kind: AgentKind): ChatProvider {
+    return {
+        kind,
+        name: kind,
+        catalog: new ModelCatalog({ defaultModel: '', profiles: {}, models: [] }),
+        capabilities: NO_CAPABILITIES,
+        command: [kind],
+        resumeCommand: '',
+        detect: () => Promise.resolve({ installed: false, version: null }),
+        firstPromptArgs: () => {
+            throw new Error(`${kind} is not offered here`);
+        },
+        createBackend: () => {
+            throw new Error(`${kind} is not offered here`);
+        }
+    };
+}
+
+const BUILT_IN_PROVIDERS: readonly ChatProvider[] = [claudeProvider, codexProvider];
+
+/* The provider of a kind, for the places that have no registry at hand. */
+export function providerFor(kind: AgentKind): ChatProvider {
+    return BUILT_IN_PROVIDERS.find((provider) => provider.kind === kind) ?? unofferedProvider(kind);
+}
+
+export interface ProviderRegistryOptions {
+    // The CLIs a host offers, in the order every menu lists them; absent, the chat CLIs this package ships.
+    providers?: ChatProvider[];
+    // The executables to probe, when they are not the ones the providers name.
+    commands?: Partial<Record<AgentKind, string>>;
+    // How to probe; a test answers without spawning anything.
+    detect?: (command: string) => Promise<CliDetection>;
+    // The environment a probe runs in.
+    env?: Record<string, string | undefined>;
+}
+
+/* What a host knows about each agent CLI: whether it is there, what it offers and what it can do. */
+export class ProviderRegistry {
+    private readonly providers: ChatProvider[];
+    private readonly commands: Partial<Record<AgentKind, string>>;
+    private readonly detect: ((command: string) => Promise<CliDetection>) | null;
+    private readonly env: Record<string, string | undefined>;
+    private readonly cache = new Map<AgentKind, { at: number; detection: CliDetection }>();
+
+    constructor(options: ProviderRegistryOptions = {}) {
+        this.providers = options.providers ?? [...BUILT_IN_PROVIDERS];
+        this.commands = options.commands ?? {};
+        this.detect = options.detect ?? null;
+        this.env = options.env ?? process.env;
+    }
+
+    async list(): Promise<ProviderInfo[]> {
+        return await Promise.all(
+            this.providers.map(async (provider) => ({
+                kind: provider.kind,
+                name: provider.name,
+                ...(await this.detection(provider)),
+                models: provider.catalog.list(),
+                defaultModel: provider.catalog.defaultModel || null,
+                capabilities: provider.capabilities,
+                resumeCommand: provider.resumeCommand
+            }))
+        );
+    }
+
+    /* The provider of a kind, one this host does not offer included. */
+    get(kind: AgentKind): ChatProvider {
+        return this.providers.find((provider) => provider.kind === kind) ?? this.fallback(kind);
+    }
+
+    /*
+     * The CLI that answers a single prompt here: the one asked for when it is installed, else the
+     * first installed provider that can, in the order the catalog lists them. Null on a machine
+     * with none, which is what hides the button that would ask.
+     */
+    async oneShotProvider(preferred?: AgentKind): Promise<ChatProvider | null> {
+        const order = preferred ? [this.get(preferred), ...this.providers] : this.providers;
+        for (const provider of order) {
+            if (provider.oneShotArgs && (await this.detection(provider)).installed) {
+                return provider;
+            }
+        }
+        return null;
+    }
+
+    catalogFor(kind: AgentKind): ModelCatalog {
+        return this.get(kind).catalog;
+    }
+
+    enabled(kind: AgentKind): boolean {
+        return this.get(kind).enabled?.() !== false;
+    }
+
+    invalidate(kind: AgentKind): void {
+        this.cache.delete(kind);
+    }
+
+    protected fallback(kind: AgentKind): ChatProvider {
+        return unofferedProvider(kind);
+    }
+
+    private async detection(provider: ChatProvider): Promise<CliDetection> {
+        if (provider.enabled?.() === false) {
+            return DISABLED;
+        }
+        const cached = this.cache.get(provider.kind);
+        if (cached && Date.now() - cached.at < DETECTION_TTL_MS) {
+            return cached.detection;
+        }
+        const command = this.commands[provider.kind] ?? provider.command[0]!;
+        const detection = this.detect ? await this.detect(command) : await provider.detect(command, this.env);
+        // Turned off while the probe ran.
+        if (provider.enabled?.() === false) {
+            return DISABLED;
+        }
+        this.cache.set(provider.kind, { at: Date.now(), detection });
+        return detection;
+    }
+}

package/src/record-directory.ts

@@ -0,0 +1,136 @@
+import { mkdir, readdir, readFile, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import type { z } from 'zod';
+import { isNotFound, writeAtomic } from './fs.ts';
+import { KeyedSerializer } from './serializer.ts';
+
+// The id is a node id or a chat id a client chose, so it is encoded before it becomes a file name.
+export function recordFileName(id: string): string {
+    return `${encodeURIComponent(id)}.json`;
+}
+
+export interface RecordDirectoryOptions<T> {
+    dir: string;
+    schema: z.ZodType<T>;
+    idOf(record: T): string;
+    write?: (path: string, text: string) => Promise<void>;
+    /*
+     * What a record read from disk is worth keeping as, for a store that drops what went stale while
+     * the host was down. Null takes the file with it.
+     */
+    keep?(record: T): T | null;
+}
+
+/*
+ * One kind of record under a host's data folder, a file per record and the whole of it in memory. A file
+ * that does not parse is left alone rather than deleted: it is a record of an older or newer host,
+ * and the one thing worse than not reading it is throwing it away.
+ */
+export class RecordDirectory<T> {
+    readonly dir: string;
+    private readonly schema: z.ZodType<T>;
+    private readonly idOf: (record: T) => string;
+    private readonly writeFile: (path: string, text: string) => Promise<void>;
+    private readonly keep: ((record: T) => T | null) | null;
+    private readonly records = new Map<string, T>();
+    // One write at a time per record, so an older one never lands after a newer one.
+    private readonly writes = new KeyedSerializer();
+
+    constructor(options: RecordDirectoryOptions<T>) {
+        this.dir = options.dir;
+        this.schema = options.schema;
+        this.idOf = options.idOf;
+        this.writeFile = options.write ?? writeAtomic;
+        this.keep = options.keep ?? null;
+    }
+
+    /* Reads what an earlier run of the host wrote down. Call before anything can ask. */
+    async load(): Promise<void> {
+        let names: string[];
+        try {
+            names = await readdir(this.dir);
+        } catch (e) {
+            if (isNotFound(e)) {
+                return;
+            }
+            throw e;
+        }
+        for (const name of names) {
+            if (!name.endsWith('.json')) {
+                continue;
+            }
+            const raw = await readFile(join(this.dir, name), 'utf8').catch(() => null);
+            if (raw === null) {
+                continue;
+            }
+            let parsed: ReturnType<typeof this.schema.safeParse>;
+            try {
+                parsed = this.schema.safeParse(JSON.parse(raw));
+            } catch {
+                continue;
+            }
+            if (!parsed.success) {
+                continue;
+            }
+            const record = this.keep === null ? parsed.data : this.keep(parsed.data);
+            if (record === null) {
+                await rm(join(this.dir, name), { force: true });
+                continue;
+            }
+            this.records.set(this.idOf(record), record);
+        }
+    }
+
+    get(id: string): T | undefined {
+        return this.records.get(id);
+    }
+
+    has(id: string): boolean {
+        return this.records.has(id);
+    }
+
+    all(): T[] {
+        return [...this.records.values()];
+    }
+
+    /*
+     * Holds the record in memory at once, so the next question in the same tick already sees it, and
+     * answers whether it is still the one this directory holds by the time the file is written. A
+     * record removed while its file was being written does not come back: the rename is undone.
+     */
+    write(record: T): Promise<boolean> {
+        const id = this.idOf(record);
+        this.records.set(id, record);
+        return this.writes.run(id, async () => {
+            if (this.records.get(id) !== record) {
+                return false;
+            }
+            await mkdir(this.dir, { recursive: true, mode: 0o700 });
+            await this.writeFile(this.pathOf(id), JSON.stringify(record));
+            if (!this.records.has(id)) {
+                await rm(this.pathOf(id), { force: true });
+                return false;
+            }
+            return true;
+        });
+    }
+
+    /* Forgets a record here and now; its file follows. */
+    remove(id: string): Promise<void> {
+        this.records.delete(id);
+        return rm(this.pathOf(id), { force: true });
+    }
+
+    /* Drops every record the predicate says is gone. */
+    async prune(drop: (record: T) => boolean): Promise<void> {
+        for (const record of this.all()) {
+            if (drop(record)) {
+                await this.remove(this.idOf(record));
+            }
+        }
+    }
+
+    private pathOf(id: string): string {
+        return join(this.dir, recordFileName(id));
+    }
+}

package/src/run-process.ts

@@ -0,0 +1,61 @@
+import { spawn } from 'node:child_process';
+
+export interface ProcessResult {
+    // Null when the process ended on a signal.
+    exitCode: number | null;
+    stdout: string;
+    stderr: string;
+}
+
+export interface RunProcessOptions {
+    env?: Record<string, string | undefined>;
+    cwd?: string;
+    // Written and closed at once; absent, the process reads from nothing.
+    stdin?: string;
+    // The process is sent a SIGTERM after this, and the run fails.
+    timeoutMs?: number;
+    timeoutMessage?: string;
+}
+
+/* One short command to its end, with what it printed. A command that cannot start rejects. */
+export function runProcess(command: readonly string[], options: RunProcessOptions = {}): Promise<ProcessResult> {
+    return new Promise((resolve, reject) => {
+        const [executable, ...args] = command;
+        if (executable === undefined) {
+            reject(new Error('No command to run'));
+            return;
+        }
+        const child = spawn(executable, args, {
+            ...(options.cwd === undefined ? {} : { cwd: options.cwd }),
+            ...(options.env === undefined ? {} : { env: options.env }),
+            stdio: [options.stdin === undefined ? 'ignore' : 'pipe', 'pipe', 'pipe']
+        });
+        const stdout: Buffer[] = [];
+        const stderr: Buffer[] = [];
+        child.stdout?.on('data', (chunk: Buffer) => stdout.push(chunk));
+        child.stderr?.on('data', (chunk: Buffer) => stderr.push(chunk));
+        const timer =
+            options.timeoutMs === undefined
+                ? null
+                : setTimeout(() => {
+                      child.kill('SIGTERM');
+                      reject(new Error(options.timeoutMessage ?? `${executable} did not finish in time`));
+                  }, options.timeoutMs);
+        child.on('error', (error) => {
+            if (timer !== null) {
+                clearTimeout(timer);
+            }
+            reject(error);
+        });
+        child.on('close', (exitCode) => {
+            if (timer !== null) {
+                clearTimeout(timer);
+            }
+            resolve({ exitCode, stdout: Buffer.concat(stdout).toString('utf8'), stderr: Buffer.concat(stderr).toString('utf8') });
+        });
+        if (options.stdin !== undefined && child.stdin) {
+            child.stdin.on('error', () => undefined);
+            child.stdin.end(options.stdin);
+        }
+    });
+}

package/src/serializer.ts

@@ -0,0 +1,41 @@
+/*
+ * One writer at a time: the next piece of work starts once the one before it settled, whether that
+ * one kept its promise or not, and every caller hears its own result. Two changes in a row never
+ * read the same file and drop one of them.
+ */
+export class Serializer {
+    private chain: Promise<unknown> = Promise.resolve();
+
+    run<T>(work: () => Promise<T>): Promise<T> {
+        const next = this.chain.then(work, work);
+        this.chain = next.catch(() => undefined);
+        return next;
+    }
+
+    /* Resolves once what is queued has settled, without adding work of its own. */
+    idle(): Promise<void> {
+        return this.chain.then(
+            () => undefined,
+            () => undefined
+        );
+    }
+}
+
+/* The same per key, for a store whose records are written one by one and never wait on each other. */
+export class KeyedSerializer {
+    private readonly chains = new Map<string, Promise<unknown>>();
+
+    run<T>(key: string, work: () => Promise<T>): Promise<T> {
+        const previous = this.chains.get(key) ?? Promise.resolve();
+        const next = previous.then(work, work);
+        const settled = next.catch(() => undefined);
+        this.chains.set(key, settled);
+        // A key whose chain ran out leaves nothing behind, or the map grows with every id ever written.
+        void settled.then(() => {
+            if (this.chains.get(key) === settled) {
+                this.chains.delete(key);
+            }
+        });
+        return next;
+    }
+}

package/src/skills.ts

@@ -0,0 +1,199 @@
+import { existsSync, type Dirent } from 'node:fs';
+import { readdir, readFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { dirname, join, parse } from 'node:path';
+import type { AgentKind, ChatSkill, ChatSkillSource } from '@adecore/agent-contracts';
+import { isNotFound } from './fs.ts';
+
+// One folder full of skill folders, and what the CLI calls the skills it finds there.
+export interface SkillRoot {
+    dir: string;
+    source: ChatSkillSource;
+    // A plugin names its skills `<plugin>:<skill>`, the way the CLI's init frame does.
+    prefix?: string;
+}
+
+export interface SkillRootOptions {
+    // The person's home directory; a test points it at a temporary tree.
+    home?: string;
+    // Where Claude Code keeps its own configuration, when it is not `<home>/.claude`.
+    claudeConfigDir?: string;
+}
+
+const NAME = /^[A-Za-z][A-Za-z0-9_:-]*$/;
+
+function unquote(value: string): string {
+    const quoted = /^(['"])([\s\S]*)\1$/.exec(value);
+    return quoted ? quoted[2]! : value;
+}
+
+/*
+ * The `key: value` pairs of a SKILL.md front matter. Enough YAML for what a skill file holds: flat
+ * keys, quoted or bare values, and the block scalars (`>-`, `|`) a long description is written as.
+ */
+export function parseFrontmatter(text: string): Record<string, string> {
+    const match = /^---\r?\n([\s\S]*?)\r?\n---/.exec(text);
+    if (!match) {
+        return {};
+    }
+    const fields: Record<string, string> = {};
+    const lines = match[1]!.split(/\r?\n/);
+    for (let i = 0; i < lines.length; i++) {
+        const pair = /^([A-Za-z0-9_-]+):[ \t]*(.*)$/.exec(lines[i]!);
+        if (!pair) {
+            continue;
+        }
+        let value = pair[2]!.trim();
+        if (value === '' || value === '>' || value === '>-' || value === '|' || value === '|-') {
+            // A block scalar puts the value on the indented lines under it; `|` keeps the newlines.
+            const keepNewlines = value.startsWith('|');
+            const parts: string[] = [];
+            while (i + 1 < lines.length && /^[ \t]+\S/.test(lines[i + 1]!)) {
+                parts.push(lines[++i]!.trim());
+            }
+            value = parts.join(keepNewlines ? '\n' : ' ');
+        }
+        fields[pair[1]!] = unquote(value);
+    }
+    return fields;
+}
+
+/*
+ * The folders from `cwd` up to and including the repository root, closest first. The home folder
+ * itself is not one of them, since its `.claude/skills` is already the user root.
+ */
+function projectDirs(cwd: string, home: string): string[] {
+    const dirs: string[] = [];
+    let current = cwd;
+    while (current !== '' && current !== parse(current).root && current !== home && current !== dirname(home) && dirs.length < 8) {
+        dirs.push(current);
+        // Anything above a repository root belongs to another project, so the walk ends there.
+        if (existsSync(join(current, '.git'))) {
+            break;
+        }
+        const parent = dirname(current);
+        if (parent === current) {
+            break;
+        }
+        current = parent;
+    }
+    return dirs;
+}
+
+/* The plugin folders Claude Code installed, each named the way its skills are addressed. */
+export async function pluginSkillRoots(configDir: string): Promise<SkillRoot[]> {
+    let raw: string;
+    try {
+        raw = await readFile(join(configDir, 'plugins', 'installed_plugins.json'), 'utf8');
+    } catch (e) {
+        if (isNotFound(e)) {
+            return [];
+        }
+        throw e;
+    }
+    let parsed: unknown;
+    try {
+        parsed = JSON.parse(raw);
+    } catch {
+        return [];
+    }
+    const plugins = typeof parsed === 'object' && parsed !== null ? (parsed as { plugins?: unknown }).plugins : undefined;
+    if (typeof plugins !== 'object' || plugins === null) {
+        return [];
+    }
+    const roots: SkillRoot[] = [];
+    for (const [key, installs] of Object.entries(plugins as Record<string, unknown>)) {
+        const name = key.split('@')[0] ?? key;
+        for (const install of Array.isArray(installs) ? installs : []) {
+            const path = typeof install === 'object' && install !== null ? (install as { installPath?: unknown }).installPath : undefined;
+            if (typeof path === 'string' && path !== '') {
+                roots.push({ dir: join(path, 'skills'), source: 'plugin', prefix: name });
+            }
+        }
+    }
+    return roots;
+}
+
+/* Where a provider's CLI looks for skills, in the order a name clash is decided. */
+export async function skillRootsFor(kind: AgentKind, cwd: string, options: SkillRootOptions = {}): Promise<SkillRoot[]> {
+    const home = options.home ?? homedir();
+    if (kind === 'codex') {
+        return [
+            { dir: join(home, '.agents', 'skills'), source: 'user' },
+            { dir: join(home, '.codex', 'skills'), source: 'user' },
+            ...projectDirs(cwd, home).map((dir): SkillRoot => ({ dir: join(dir, '.agents', 'skills'), source: 'project' }))
+        ];
+    }
+    const configDir = options.claudeConfigDir ?? join(home, '.claude');
+    return [
+        { dir: join(configDir, 'skills'), source: 'user' },
+        ...projectDirs(cwd, home).map((dir): SkillRoot => ({ dir: join(dir, '.claude', 'skills'), source: 'project' })),
+        ...(await pluginSkillRoots(configDir))
+    ];
+}
+
+async function readSkill(root: SkillRoot, folder: string): Promise<ChatSkill | null> {
+    let text: string;
+    try {
+        text = await readFile(join(root.dir, folder, 'SKILL.md'), 'utf8');
+    } catch {
+        return null;
+    }
+    const fields = parseFrontmatter(text);
+    const own = fields.name && NAME.test(fields.name) ? fields.name : folder;
+    const name = root.prefix ? `${root.prefix}:${own}` : own;
+    if (!NAME.test(name)) {
+        return null;
+    }
+    return { name, description: fields.description ?? '', source: root.source };
+}
+
+/* Every skill under these roots, sorted by name; the first root that carries a name wins. */
+export async function scanSkillRoots(roots: SkillRoot[]): Promise<ChatSkill[]> {
+    const found = new Map<string, ChatSkill>();
+    for (const root of roots) {
+        let entries: Dirent[];
+        try {
+            entries = await readdir(root.dir, { withFileTypes: true });
+        } catch {
+            continue;
+        }
+        // A skill manager links each skill in from a shared folder; a link to anything but a skill folder reads as no skill.
+        const folders = entries.filter((entry) => entry.isDirectory() || entry.isSymbolicLink());
+        const skills = await Promise.all(folders.map((entry) => readSkill(root, entry.name)));
+        for (const skill of skills) {
+            if (skill && !found.has(skill.name)) {
+                found.set(skill.name, skill);
+            }
+        }
+    }
+    return [...found.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+
+export async function discoverSkills(kind: AgentKind, cwd: string, options: SkillRootOptions = {}): Promise<ChatSkill[]> {
+    return scanSkillRoots(await skillRootsFor(kind, cwd, options));
+}
+
+// How long a scan stays good; a skill written mid-session shows up on the next look.
+const CACHE_TTL_MS = 30_000;
+
+/* The skills of one CLI in one folder, scanned at most once per half minute. There is no watcher. */
+export class SkillIndex {
+    private readonly options: SkillRootOptions;
+    private readonly cache = new Map<string, { at: number; skills: ChatSkill[] }>();
+
+    constructor(options: SkillRootOptions = {}) {
+        this.options = options;
+    }
+
+    async list(kind: AgentKind, cwd: string): Promise<ChatSkill[]> {
+        const key = `${kind}:${cwd}`;
+        const cached = this.cache.get(key);
+        if (cached && Date.now() - cached.at < CACHE_TTL_MS) {
+            return cached.skills;
+        }
+        const skills = await discoverSkills(kind, cwd, this.options);
+        this.cache.set(key, { at: Date.now(), skills });
+        return skills;
+    }
+}

package/src/tasks/background-limit.ts

@@ -0,0 +1,72 @@
+import { commandLabel, runningInBackground } from '../chat/background-work.ts';
+import { loadChat, type ChatOpenerDeps } from '../chat/wake-chat.ts';
+import type { OutboxOutcome } from '../outbox/outbox-worker.ts';
+import type { TaskCoordinator, TaskCoordinatorDeps } from './task-coordinator.ts';
+import type { TaskStore } from './task-store.ts';
+import { isBackgroundLimit, type AnyOutboxEntry, type BackgroundLimitEntry, type TaskOutbox } from './task-work.ts';
+
+export interface BackgroundLimitDeps extends ChatOpenerDeps {
+    tasks: Pick<TaskStore, 'get'>;
+    coordinator: Pick<TaskCoordinator, 'outlasted'>;
+}
+
+/*
+ * The limit on a child's background commands passed, or a restart took them down. Its task settles on
+ * the child's last turn (failed after a restart), unless something else settled it first or a subagent
+ * or a workflow now holds it, which has no limit; a turn in flight may still answer it, so the limit
+ * looks again once that turn ended.
+ */
+export function backgroundLimitHandler(deps: BackgroundLimitDeps) {
+    return async (entry: BackgroundLimitEntry): Promise<OutboxOutcome> => {
+        if (deps.tasks.get(entry.payload.taskId)?.status !== 'open') {
+            return;
+        }
+        const chat = await loadChat(deps, entry.target);
+        if (chat === null) {
+            return;
+        }
+        if (chat.info.activeTurnId !== null) {
+            return 'wait';
+        }
+        if (runningInBackground(chat.thread.list()).length > 0) {
+            return;
+        }
+        // A child whose process went since the limit started runs nothing any more; what it ran then is what the parent is told.
+        const running = (chat.info.background ?? []).map(commandLabel);
+        await deps.coordinator.outlasted(entry.target, running.length > 0 ? running : entry.payload.commands, entry.payload.restarted ? 'restart' : 'limit');
+    };
+}
+
+export interface RestartedOutbox {
+    list(): readonly AnyOutboxEntry[];
+    update(entry: BackgroundLimitEntry): Promise<void>;
+}
+
+/*
+ * Every limit still owed when the host starts was owed by an earlier run, and the CLI whose commands
+ * it waits on went down with that run, so nothing is left to wait for: each is due now and fails its
+ * task. Call after the outbox loaded and before its worker starts.
+ */
+export async function restartBackgroundLimits(outbox: RestartedOutbox, now: number): Promise<void> {
+    for (const entry of outbox.list()) {
+        if (isBackgroundLimit(entry)) {
+            await outbox.update({ ...entry, notBefore: now, payload: { ...entry.payload, restarted: true } });
+        }
+    }
+}
+
+/* The `background-limit` entries of a host's outbox, one per task at most, as the coordinator owes and drops them. */
+export function backgroundLimits(outbox: Pick<TaskOutbox, 'list' | 'enqueue' | 'remove'>): TaskCoordinatorDeps['limit'] {
+    return {
+        owed: (taskId) => outbox.list().some((entry) => isBackgroundLimit(entry) && entry.payload.taskId === taskId),
+        owe: (task, commands, at) =>
+            outbox.enqueue(task.projectId, task.childId, { kind: 'background-limit', payload: { taskId: task.id, commands: [...commands] } }, at),
+        lapse: async (taskId) => {
+            for (const entry of outbox.list()) {
+                if (isBackgroundLimit(entry) && entry.payload.taskId === taskId) {
+                    await outbox.remove(entry.id);
+                }
+            }
+        }
+    };
+}