@adecore/agents 0.39.0 → 0.40.1

package/src/host/wiring.ts

@@ -67,6 +67,7 @@ async function installRulesIn(kind: AgentKind, folder: string, rules: CodexRules
     if (kind !== 'codex') {
         return;
     }
+
     const path = codexRulesPathIn(folder, rules);
     await installCodexRules(path, rules).catch((e: unknown) => console.error(`Could not write the codex rules in ${path}:`, errorText(e)));
 }
@@ -82,6 +83,7 @@ export function wireAgents<Core extends ChatCore = ChatCore>(options: AgentWirin
     const client = options.client ?? DEFAULT_CODEX_CLIENT;
     const codexRules = options.codexRules;
     const providers = new ProviderRegistry({ providers: [createClaudeProvider(options.claude), createCodexProvider({ client })], env, detect: options.detect });
+
     const accounts = new ProviderAccountsService({
         home: options.dataDir,
         providers,
@@ -90,15 +92,19 @@ export function wireAgents<Core extends ChatCore = ChatCore>(options: AgentWirin
         ...(options.accountsHost ? { host: options.accountsHost } : {}),
         ...(codexRules ? { install: (kind: AgentKind, folder: string) => installRulesIn(kind, folder, codexRules) } : {})
     });
+
     if (codexRules) {
         void installRulesIn('codex', defaultCodexHome(env), codexRules);
     }
+
     const nameOf = (kind: AgentKind | UsageProvider): string => providers.get(kind).name;
+
     const limits = new UsageMonitor({ providers, accounts: limitAccountsOf(accounts, nameOf, env), client });
     accounts.listen(() => limits.accountsChanged());
     const attachments = new AttachmentStore(options.dataDir);
     // Only without `core`, where `Core` is `ChatCore` itself.
     const core = options.core ?? ((coreOptions: ChatCoreOptions) => new ChatCore(coreOptions) as Core);
+
     const chats = core({
         providers,
         store: new ChatStore(options.dataDir, { attachments }),
@@ -116,6 +122,7 @@ export function wireAgents<Core extends ChatCore = ChatCore>(options: AgentWirin
         claudeTitles: new ClaudeTitleReader(),
         nameChat: (kind, input) => suggestChatTitle(providers, kind, input, definedEnv(env))
     });
+
     const usage = new UsageService({
         home: options.dataDir,
         knownProjects: () => Promise.resolve([]),
@@ -123,6 +130,7 @@ export function wireAgents<Core extends ChatCore = ChatCore>(options: AgentWirin
         sessionAccounts: () => chatSessionAccounts(chats.list()),
         accounts: () => usageAccountsOf(accounts, nameOf)
     });
+
     return {
         providers,
         accounts,
@@ -141,10 +149,12 @@ export function wireAgents<Core extends ChatCore = ChatCore>(options: AgentWirin
                 usage.subscribe(clientId, send),
                 limits.subscribe(clientId, send)
             ];
+
             return () => {
                 for (const release of releases) {
                     release();
                 }
+
                 chats.detachAll(clientId);
                 usage.unfollow(clientId);
             };

package/src/index.ts

@@ -7,6 +7,7 @@ export { RecordDirectory, type RecordDirectoryOptions } from './record-directory
 export { runProcess, type ProcessResult, type RunProcessOptions } from './run-process.ts';
 export { Serializer, KeyedSerializer } from './serializer.ts';
 export { cleanTitle, readLines } from './title-file.ts';
+
 export {
     type DirectoryWatcher,
     type WatchSeams,

package/src/lineage.ts

@@ -60,24 +60,30 @@ export class AgentLineageStore {
     descendants(nodeId: string): string[] {
         const found: string[] = [];
         const seen = new Set([nodeId]);
+        const entries = this.opened.all();
+
         for (let i = -1; i < found.length; i++) {
             const parent = i === -1 ? nodeId : found[i]!;
-            for (const entry of this.opened.all()) {
+
+            for (const entry of entries) {
                 if (entry.openedBy === parent && openedByAgent(entry) && entry.endedAt === undefined && !seen.has(entry.nodeId)) {
                     seen.add(entry.nodeId);
                     found.push(entry.nodeId);
                 }
             }
         }
+
         return found;
     }
 
     /* Moves a node's record to another project with its dates as they were; false when nothing was written down for it or a prune took it meanwhile. */
     async rehome(nodeId: string, projectId: string): Promise<boolean> {
         const entry = this.opened.get(nodeId);
+
         if (entry === undefined) {
             return false;
         }
+
         return this.opened.write({ ...entry, projectId });
     }
 
@@ -93,8 +99,10 @@ export class AgentLineageStore {
     /* On the wall clock, like `createdAt`: a chat holds the mark against the time its turn started. */
     async markEnded(nodeIds: readonly string[]): Promise<void> {
         const at = Date.now();
+
         for (const nodeId of nodeIds) {
             const entry = this.opened.get(nodeId);
+
             if (entry && entry.endedAt === undefined) {
                 await this.opened.write({ ...entry, endedAt: at });
             }
@@ -103,7 +111,8 @@ export class AgentLineageStore {
 
     /* The nodes of this project whose opener it no longer places, and that no cascade ended yet. */
     orphans(projectId: string, ids: ReadonlySet<string>): Array<{ nodeId: string; openedBy: string }> {
-        return [...this.opened.all()]
+        return this.opened
+            .all()
             .filter(
                 (entry) =>
                     entry.projectId === projectId && openedByAgent(entry) && entry.endedAt === undefined && ids.has(entry.nodeId) && !ids.has(entry.openedBy)
@@ -114,6 +123,7 @@ export class AgentLineageStore {
     /* The widest mode this agent node may start in, every time it starts; null for one no agent opened. */
     ceilingOf(nodeId: string): RuntimeMode | null {
         const entry = this.opened.get(nodeId);
+
         return entry !== undefined && openedByAgent(entry) ? (entry.ceiling ?? null) : null;
     }
 
@@ -122,7 +132,7 @@ export class AgentLineageStore {
         return this.opened.get(nodeId)?.peer ?? null;
     }
 
-    /* How deep a node sits. A node nobody wrote down is one a person made, which is where a chain starts. */
+    /* A node nobody wrote down is one a person made, which is where a chain starts. */
     depthOf(nodeId: string): number {
         return this.opened.get(nodeId)?.depth ?? 0;
     }
@@ -130,39 +140,48 @@ export class AgentLineageStore {
     // A host may exclude completed hidden agents while keeping their lineage for later reads and tasks.
     openedCount(callerId: string, include: (nodeId: string) => boolean = () => true): number {
         let count = 0;
+
         for (const entry of this.opened.all()) {
             if (entry.openedBy === callerId && openedByAgent(entry) && include(entry.nodeId)) {
                 count += 1;
             }
         }
+
         return count;
     }
 
     /* Who made this node, or null for one a person made: the whole of the rule node delete follows. */
     madeBy(nodeId: string): string | null {
         const entry = this.opened.get(nodeId);
+
         return entry === undefined || entry.relation === 'fork' ? null : entry.openedBy;
     }
 
     /* The node that opened this one as an agent, or null for a node no agent or team started. */
     startedBy(nodeId: string): string | null {
         const entry = this.opened.get(nodeId);
+
         return entry !== undefined && openedByAgent(entry) ? entry.openedBy : null;
     }
 
     /* The chat a fork was made from, or null for a node that is no fork. */
     forkedFrom(nodeId: string): string | null {
         const entry = this.opened.get(nodeId);
+
         return entry?.relation === 'fork' ? entry.openedBy : null;
     }
 
     forksOf(nodeId: string): string[] {
-        return [...this.opened.all()].filter((entry) => entry.relation === 'fork' && entry.openedBy === nodeId).map((entry) => entry.nodeId);
+        return this.opened
+            .all()
+            .filter((entry) => entry.relation === 'fork' && entry.openedBy === nodeId)
+            .map((entry) => entry.nodeId);
     }
 
     /* The forks of this project whose node is gone, read before `prune` forgets them. */
     forksLeaving(projectId: string, ids: ReadonlySet<string>): string[] {
-        return [...this.opened.all()]
+        return this.opened
+            .all()
             .filter((entry) => entry.projectId === projectId && entry.relation === 'fork' && !ids.has(entry.nodeId))
             .map((entry) => entry.nodeId);
     }

package/src/messages/deliver-message.ts

@@ -36,18 +36,24 @@ export function deliverMessageHandler(deps: DeliverMessageDeps) {
         if (!deps.placed(entry.target)) {
             return;
         }
+
         const waiting = deps.notices.waiting(entry.target);
+
         // A turn opened for an earlier message took these along, or they went stale: nothing to wake anyone for.
         if (waiting.length === 0) {
             return;
         }
+
         const chat = await deps.chat(entry.target);
+
         if (chat === null) {
             return;
         }
+
         if (chat.relocating?.() === true) {
             return 'wait';
         }
+
         // No note and no preamble on the thread: a person read the message as it landed (`showNotices`),
         // and the label on the turn names who it came from.
         chat.wake({

package/src/messages/deliver-notice.ts

@@ -40,18 +40,23 @@ export interface ChatDelivery {
  */
 export function turnFromMessage(items: readonly ChatItem[], activeTurnId: string | null): boolean {
     const from = activeTurnId === null ? items.findLastIndex((item) => item.kind === 'turn') : items.findIndex((item) => item.id === activeTurnId);
+
     for (let i = from; i >= 0; i--) {
         const turn = items[i]!;
+
         if (turn.kind !== 'turn') {
             continue;
         }
+
         if ((turn.messageFrom ?? []).length > 0) {
             return true;
         }
+
         if (turn.origin !== 'agent' || turn.taskIds !== undefined || turn.summaryFor !== undefined) {
             return false;
         }
     }
+
     return false;
 }
 
@@ -60,14 +65,17 @@ export function chatNoticeTargets(chats: Pick<ChatCore, 'get' | 'hasStored'>): C
     return {
         chat: async (id) => {
             const session = chats.get(id);
+
             if (session) {
                 return session.info.activeTurnId === null ? 'idle' : 'running';
             }
+
             // A chat nobody has loaded is idle: the turn opens on the thread the host reads back from disk.
             return (await chats.hasStored(id)) ? 'idle' : 'none';
         },
         fromMessage: (id) => {
             const session = chats.get(id);
+
             return session !== undefined && turnFromMessage(session.thread.list(), session.info.activeTurnId);
         }
     };
@@ -82,15 +90,19 @@ export function chatNoticeTargets(chats: Pick<ChatCore, 'get' | 'hasStored'>): C
 export async function deliverToChat(store: Pick<NoticeStore, 'put'>, targets: ChatNoticeTargets, notice: Omit<Notice, 'createdAt'>): Promise<ChatDelivery> {
     const waiting = await store.put(notice);
     const chat = await targets.chat(notice.targetId);
+
     if (chat === 'none') {
         return { outcome: 'no-chat', waiting };
     }
+
     if (chat === 'running') {
         return { outcome: 'in-turn', waiting };
     }
+
     if (targets.fromMessage(notice.from)) {
         return { outcome: 'from-message', waiting };
     }
+
     return { outcome: 'wake', waiting };
 }
 
@@ -110,6 +122,7 @@ export async function showNotices(store: Pick<NoticeStore, 'show'>, chat: Notice
     if (!(await chat.has(targetId))) {
         return;
     }
+
     for (const notice of await store.show(targetId)) {
         await chat.note(targetId, words.shown(notice));
     }

package/src/messages/notice-store.ts

@@ -37,10 +37,9 @@ const FileSchema = z.object({ notices: z.array(NoticeSchema).min(1) });
 type NoticeFile = z.infer<typeof FileSchema>;
 
 /*
- * The messages waiting for each node, held until that node's agent has a moment to hear them, under
- * `<dataDir>/notices`. On disk because the receiver may well be a node nobody has mounted yet, and a
- * host that restarts must not lose what was left for it. Delivered once, whichever channel gets there
- * first.
+ * The messages waiting for each node, held until that node's agent has a moment to hear them. On disk
+ * because the receiver may well be a node nobody has mounted yet, and a host that restarts must not
+ * lose what was left for it.
  */
 export class NoticeStore {
     readonly dir: string;
@@ -51,6 +50,7 @@ export class NoticeStore {
     constructor(dataDir: string, now: () => number = Date.now) {
         this.dir = join(dataDir, 'notices');
         this.now = now;
+
         this.queues = new RecordDirectory({
             dir: this.dir,
             schema: FileSchema,
@@ -58,6 +58,7 @@ export class NoticeStore {
             // What went stale while the host was down is not delivered; a queue of nothing else goes.
             keep: (file) => {
                 const fresh = file.notices.filter((notice) => this.fresh(notice));
+
                 return fresh[0] === undefined ? null : { notices: fresh };
             }
         });
@@ -71,6 +72,7 @@ export class NoticeStore {
     async put(notice: Omit<Notice, 'createdAt'>): Promise<number> {
         const queue = [...this.waiting(notice.targetId), { ...notice, createdAt: this.now() }].slice(-MAX_NOTICES);
         await this.persist(notice.targetId, queue);
+
         return queue.length;
     }
 
@@ -82,10 +84,13 @@ export class NoticeStore {
      */
     take(targetId: string): Notice[] {
         const queue = this.waiting(targetId);
+
         if (queue.length === 0) {
             return [];
         }
+
         this.lastDrop = this.persist(targetId, []).catch((e) => console.error(`Dropping the messages of ${targetId} failed:`, errorText(e)));
+
         return queue;
     }
 
@@ -101,22 +106,27 @@ export class NoticeStore {
     async show(targetId: string): Promise<Notice[]> {
         const queue = this.waiting(targetId);
         const unshown = queue.filter((notice) => notice.shown !== true);
+
         if (unshown.length === 0) {
             return [];
         }
+
         await this.persist(
             targetId,
             queue.map((notice) => ({ ...notice, shown: true }))
         );
+
         return unshown;
     }
 
     /* What waits for a node, without taking it; the stale ones are already gone from the answer. */
     waiting(targetId: string): Notice[] {
         const file = this.queues.get(targetId);
+
         if (file === undefined) {
             return [];
         }
+
         return file.notices.filter((notice) => this.fresh(notice));
     }
 
@@ -133,8 +143,10 @@ export class NoticeStore {
     private async persist(targetId: string, queue: Notice[]): Promise<void> {
         if (queue.length === 0) {
             await this.queues.remove(targetId);
+
             return;
         }
+
         await this.queues.write({ notices: queue });
     }
 }

package/src/modes.ts

@@ -32,6 +32,7 @@ export function ceilingForOpening(opener: RuntimeMode, requested: RuntimeMode |
             modeLines(opener)
         );
     }
+
     return opener;
 }
 

package/src/outbox/outbox-worker.ts

@@ -67,6 +67,7 @@ export class OutboxWorker<Work extends OutboxWorkShape> {
 
     stop(): void {
         this.started = false;
+
         if (this.timer !== null) {
             this.clock.clearTimeout(this.timer);
             this.timer = null;
@@ -87,11 +88,13 @@ export class OutboxWorker<Work extends OutboxWorkShape> {
     wake(target: string): void {
         this.wakes.set(target, (this.wakes.get(target) ?? 0) + 1);
         let woke = false;
+
         for (const entry of this.store.list()) {
             if (entry.target === target && this.waiting.delete(entry.id)) {
                 woke = true;
             }
         }
+
         if (woke) {
             queueMicrotask(() => this.drain());
         }
@@ -102,6 +105,7 @@ export class OutboxWorker<Work extends OutboxWorkShape> {
         if (this.isSettled()) {
             return Promise.resolve();
         }
+
         return new Promise((resolve) => {
             this.waiters.push(resolve);
         });
@@ -110,57 +114,76 @@ export class OutboxWorker<Work extends OutboxWorkShape> {
     private drain(): void {
         if (!this.started) {
             this.notifySettled();
+
             return;
         }
+
         const now = this.clock.now();
         const busy = new Set(this.running);
         let nextDue: number | null = null;
+
         const dueAt = (at: number): void => {
             nextDue = nextDue === null ? at : Math.min(nextDue, at);
         };
+
         for (const entry of this.store.list()) {
             // A waiting entry holds no lane. The resume of a chat must not queue behind a wake that waits for it.
             if (busy.has(entry.target) || this.waiting.has(entry.id)) {
                 continue;
             }
+
             // Nor does work due at a later time, which nothing owed before it has to wait for.
             if (entry.attempts === 0 && entry.notBefore > now) {
                 dueAt(entry.notBefore);
+
                 continue;
             }
+
             const lanes = this.store.lanesOf(entry);
+
             // Oldest first per target. A younger entry never overtakes one that waits out a retry.
             for (const lane of lanes) {
                 busy.add(lane);
             }
+
             // The other lanes only wait for work that is running; work that is merely owed there is what ending takes away.
             if (lanes.some((lane) => lane !== entry.target && this.running.has(lane))) {
                 continue;
             }
+
             if (entry.notBefore > now) {
                 dueAt(entry.notBefore);
+
                 continue;
             }
+
             void this.run(entry);
         }
+
         this.schedule(nextDue, now);
         this.notifySettled();
     }
 
     private async run(entry: OutboxEntryOf<Work>): Promise<void> {
         const lanes = this.store.lanesOf(entry);
+
         for (const lane of lanes) {
             this.running.add(lane);
         }
+
         const woken = this.wakes.get(entry.target) ?? 0;
+
         try {
             const outcome = await (this.handlers[entry.kind as Work['kind']] as (entry: OutboxEntryOf<Work>) => Promise<OutboxOutcome>)(entry);
+
             if (outcome === 'wait') {
                 if ((this.wakes.get(entry.target) ?? 0) === woken && this.store.has(entry.id)) {
                     this.waiting.add(entry.id);
                 }
+
                 return;
             }
+
             await this.store.remove(entry.id);
         } catch (e) {
             await this.failed(entry, e).catch((error: unknown) => console.error(`The outbox could not record a failed ${entry.kind}:`, errorText(error)));
@@ -168,18 +191,22 @@ export class OutboxWorker<Work extends OutboxWorkShape> {
             for (const lane of lanes) {
                 this.running.delete(lane);
             }
+
             this.drain();
         }
     }
 
     private async failed(entry: OutboxEntryOf<Work>, error: unknown): Promise<void> {
         const delay = RETRY_DELAYS_MS[entry.attempts];
+
         if (delay === undefined) {
             await this.store.remove(entry.id);
             console.error(`Gave up on ${entry.kind} for ${entry.target}:`, errorText(error));
             this.onParked(entry, error);
+
             return;
         }
+
         await this.store.update({ ...entry, attempts: entry.attempts + 1, notBefore: this.clock.now() + delay });
     }
 
@@ -188,6 +215,7 @@ export class OutboxWorker<Work extends OutboxWorkShape> {
             this.clock.clearTimeout(this.timer);
             this.timer = null;
         }
+
         if (nextDue !== null) {
             this.timer = this.clock.setTimeout(
                 () => {
@@ -201,6 +229,7 @@ export class OutboxWorker<Work extends OutboxWorkShape> {
 
     private isSettled(): boolean {
         const now = this.clock.now();
+
         return this.running.size === 0 && (!this.started || !this.store.list().some((entry) => entry.notBefore <= now && !this.waiting.has(entry.id)));
     }
 
@@ -208,8 +237,10 @@ export class OutboxWorker<Work extends OutboxWorkShape> {
         if (!this.isSettled()) {
             return;
         }
+
         const waiting = this.waiters;
         this.waiters = [];
+
         for (const resolve of waiting) {
             resolve();
         }

package/src/outbox/outbox.ts

@@ -45,11 +45,13 @@ export class OutboxStore<Work extends OutboxWorkShape> {
 
     constructor(options: OutboxStoreOptions<Work>) {
         this.dir = join(options.dataDir, 'outbox');
+
         this.entries = new RecordDirectory<OutboxEntryOf<Work>>({
             dir: this.dir,
             schema: z.intersection(options.work, OutboxEntryFieldsSchema),
             idOf: (entry) => entry.id
         });
+
         this.lanes = options.lanesOf ?? ((entry) => [entry.target]);
         this.outlivesTarget = options.outlivesTarget ?? (() => false);
     }
@@ -70,7 +72,9 @@ export class OutboxStore<Work extends OutboxWorkShape> {
             attempts: 0,
             notBefore
         };
+
         await this.entries.write(entry);
+
         return entry;
     }
 
@@ -79,6 +83,7 @@ export class OutboxStore<Work extends OutboxWorkShape> {
         if (!this.entries.has(entry.id)) {
             return;
         }
+
         await this.entries.write(entry);
     }