agents-relay 1.0.101 → 1.0.103

package/dist/dashboard-html.js

@@ -260,7 +260,8 @@ async function refresh(force=false){jobsRefresh.disabled=true;jobsRefresh.textCo
 function renderEventScope(){const task=eventTaskId&&selected()?.tasks?.find(candidate=>candidate.id===eventTaskId);eventsAllTasks.disabled=!task;eventsAllTasks.setAttribute('aria-pressed',String(!task));eventsScope.textContent=task?'Task '+task.id+' · newest first · 60 max':'Job-wide · newest first · 60 max';}
 function eventLabel(type){return ({'task.process.launched':'Process launched','task.started':'Worker started','task.process.exited':'Sync process exited','task.process.async_exited':'Async process exited','task.completed':'Worker completed','task.failed':'Worker failed','task.blocked':'Worker blocked','review.started':'Review started','review.approved':'Review approved','review.changes_required':'Review changes required','review.blocked':'Review blocked'})[type]||type||'Event';}
 function addEvent(event,level){if(!event||selectedJob&&event.job_id&&event.job_id!==selectedJob||eventTaskId&&event.task_id!==eventTaskId)return;if(event.event_id&&displayedEventIds.has(event.event_id))return;if(event.event_id)displayedEventIds.add(event.event_id);const item=element('li','event-item');const meta=element('div','event-meta');meta.append(element('span','event-kind',text(eventLabel(event.type))),element('span','event-type',text(event.type||'event')),element('span','',text(relativeTime(event.timestamp))),element('span','',text('task: '+value(event.task_id))));item.append(meta);const message=element('p','event-message',text(event.message||'Event received'));if(level==='error'||event.level==='error')message.classList.add('error-text');item.append(message);eventFeed.querySelector('.empty')?.remove();eventFeed.prepend(item);while(eventFeed.children.length>MAX_EVENTS)eventFeed.lastElementChild?.remove();}
-function usageBar(label,windowData){const percent=Math.max(0,Math.min(100,100-windowData.usedPercent));const row=element('div','usage-row');const heading=element('div','usage-label');heading.append(element('span','',text(label)),element('span','',text(Math.round(percent)+'%')));const track=element('div','usage-track');track.setAttribute('role','progressbar');track.setAttribute('aria-label',label+' available');track.setAttribute('aria-valuemin','0');track.setAttribute('aria-valuemax','100');track.setAttribute('aria-valuenow',String(percent));const fill=element('div','usage-fill');fill.style.width=percent+'%';track.append(fill);row.append(heading,track);return row;}
+function resetText(windowData){if(!Number.isFinite(windowData.resetsAt))return '';const at=new Date(windowData.resetsAt*1000);const minutes=Math.max(0,Math.ceil((at.getTime()-Date.now())/60000));const relative=minutes<60?minutes+'m':minutes<1440?Math.floor(minutes/60)+'h '+minutes%60+'m':Math.floor(minutes/1440)+'d '+Math.floor((minutes%1440)/60)+'h';return 'Resets '+at.toLocaleString()+' · in '+relative;}
+function usageBar(label,windowData){const percent=Math.max(0,Math.min(100,100-windowData.usedPercent));const row=element('div','usage-row');const heading=element('div','usage-label');heading.append(element('span','',text(label)),element('span','',text(Math.round(percent)+'%')));const track=element('div','usage-track');track.setAttribute('role','progressbar');track.setAttribute('aria-label',label+' available');track.setAttribute('aria-valuemin','0');track.setAttribute('aria-valuemax','100');track.setAttribute('aria-valuenow',String(percent));const fill=element('div','usage-fill');fill.style.width=percent+'%';track.append(fill);row.append(heading,track);const reset=resetText(windowData);if(reset)row.append(element('div','subtle',text(reset)));return row;}
 function usageProvider(provider){const card=element('section','usage-provider');card.append(element('h3','',text(provider.label)));const usage=provider.usage||{};if(!usage.available||!usage.fiveHour||!usage.weekly){card.append(element('p','empty',text(usage.reason||'Account usage telemetry is unavailable.')));return card;}const bars=element('div','usage-bars');bars.append(usageBar('5-hour remaining',usage.fiveHour),usageBar('Weekly remaining',usage.weekly));card.append(bars);return card;}
 function formatCredit(value,currency){if(value===null||value===undefined||!Number.isFinite(Number(value)))return '—';const number=Number(value);if(currency==='USD')return '$'+number.toFixed(2);if(currency==='CNY')return '¥'+number.toFixed(2);return number.toFixed(2)+' '+currency;}
 function creditProvider(provider){const row=element('section','usage-provider');row.append(element('h3','',text(provider.label)));const credits=provider.credits||{};if(!credits.available||!Array.isArray(credits.balances)||!credits.balances.length){row.append(element('p','empty',text(credits.reason||'Credit balance is unavailable.')));return row;}const balance=credits.balances[0];row.append(element('div','detail-value',text(formatCredit(balance.remaining,balance.currency))));return row;}

package/dist/model-routing.js

@@ -38,7 +38,7 @@ async function readConfig(path) {
 }
 function withResource(candidate, usage) {
     const resource = usageForProvider(usage, candidate.provider);
-    return { ...candidate, resourceHealthy: resource.healthy, resourceUsedPercent: resource.usedPercent };
+    return { ...candidate, resourceHealthy: resource.healthy, resourceUsedPercent: resource.usedPercent, resourceRemainingPercent: resource.remainingPercent, resourceResetAt: resource.resetAt, resourceResetInMinutes: resource.resetInMinutes, resourceWindows: resource.windows };
 }
 export async function discoverModelCandidates(worker, registered, usage, codexHome = process.env.CODEX_HOME ?? join(homedir(), '.codex')) {
     const registration = registered.find(item => item.id === worker.workerId);
@@ -105,9 +105,9 @@ export async function routeModel(worker, candidates, options = {}) {
             facts: JSON.parse(JSON.stringify({
                 task: options.taskFacts ?? {},
                 worker: { id: worker.workerId, adapter: worker.adapter, capabilities: [...worker.capabilities] },
-                candidates: eligible.map(item => ({ id: item.id, provider: item.provider, model: item.model, profile: item.profile ?? null, reasoning: item.reasoning ?? null, resourceHealthy: item.resourceHealthy ?? null, resourceUsedPercent: item.resourceUsedPercent ?? null })),
+                candidates: eligible.map(item => ({ id: item.id, provider: item.provider, model: item.model, profile: item.profile ?? null, reasoning: item.reasoning ?? null, resourceHealthy: item.resourceHealthy ?? null, resourceUsedPercent: item.resourceUsedPercent ?? null, resourceRemainingPercent: item.resourceRemainingPercent ?? null, resourceResetAt: item.resourceResetAt ?? null, resourceResetInMinutes: item.resourceResetInMinutes ?? null, resourceWindows: item.resourceWindows ?? null })),
             })),
-        }, { type: 'choice', question: 'Which eligible model profile is best suited to execute this task?', choices: eligible.map(item => item.id) }, () => deterministic.id);
+        }, { type: 'choice', question: 'Which eligible model profile is best suited to execute this task? Prefer spending otherwise-expiring paid quota on stronger reasoning when reset is near and substantial capacity remains, but consider every quota window so a tighter longer-horizon limit is not needlessly depleted; never violate task fit or continuity.', choices: eligible.map(item => item.id) }, () => deterministic.id);
     const selected = eligible.find(item => item.id === choice.choice) ?? deterministic;
     return {
         candidate: selected,

package/dist/reconciler-runtime.js

@@ -86,6 +86,27 @@ export class ReconcilerRuntimeBase {
     }
     async idle() { while (this.live.size > 0 || this.plannerLive.size > 0 || this.continuationLive.size > 0 || this.reconciling)
         await new Promise(resolve => setTimeout(resolve, 25)); }
+    async close() {
+        for (const live of this.live.values()) {
+            live.controller.abort();
+            live.execution.cancel();
+        }
+        this.live.clear();
+        for (const timer of this.terminalTimers.values())
+            clearTimeout(timer);
+        this.terminalTimers.clear();
+        for (const timer of this.terminalExitGraceTimers.values())
+            clearTimeout(timer);
+        this.terminalExitGraceTimers.clear();
+        for (const planner of this.plannerLive.values()) {
+            clearTimeout(planner.timer);
+            planner.controller.abort();
+        }
+        this.plannerLive.clear();
+        for (const waiter of this.terminalWaiters.values())
+            waiter.resolve();
+        this.terminalWaiters.clear();
+    }
     async wake(jobId) { return this.reconcile(jobId); }
     async startAck(jobId, taskId, sourceId, launchBarrier, timeoutMs = this.options.startAckTimeoutMs ?? 60000) {
         if (!this.options.eventBus)

package/dist/reconciler.js

@@ -146,8 +146,13 @@ export class Reconciler extends ReconcilerReviewBase {
                     this.plannerLive.get(task.id)?.controller.abort();
                 }
             const beforeSchedule = await this.store.load(jobId);
+            const taskStatesBeforeSchedule = new Map(beforeSchedule.tasks.map(task => [task.id, task.state]));
             const scheduleBefore = JSON.stringify(beforeSchedule.schedule ?? null);
             let scheduled = schedule(beforeSchedule);
+            for (const task of scheduled.tasks) {
+                if (taskStatesBeforeSchedule.get(task.id) !== task.state)
+                    await this.store.saveTask(task);
+            }
             if (scheduled.state !== previousState || JSON.stringify(scheduled.schedule ?? null) !== scheduleBefore)
                 await this.store.saveJob(scheduled);
             if (prState === 'OPEN') {

package/dist/worker-routing.js

@@ -1,9 +1,31 @@
 import { chooseWithDecision } from './decision.js';
-export function usageForProvider(snapshot, provider) {
+export function usageForProvider(snapshot, provider, now = Date.now()) {
     const usage = snapshot?.providers.find(item => item.id === provider)?.usage;
     if (usage?.available) {
         const usedPercent = Math.max(usage.fiveHour?.usedPercent ?? 0, usage.weekly?.usedPercent ?? 0);
-        return { healthy: usedPercent < 100, usedPercent };
+        const resourceWindow = (window) => {
+            if (!window)
+                return undefined;
+            const resetAt = window.resetsAt;
+            return {
+                remainingPercent: 100 - window.usedPercent,
+                resetAt,
+                resetInMinutes: resetAt === null ? null : Math.max(0, Math.ceil((resetAt * 1000 - now) / 60_000)),
+            };
+        };
+        const windows = { fiveHour: resourceWindow(usage.fiveHour), weekly: resourceWindow(usage.weekly) };
+        const resetWindow = [usage.fiveHour, usage.weekly]
+            .filter((window) => window?.resetsAt !== null && window?.resetsAt !== undefined)
+            .filter(window => window.resetsAt * 1000 > now)
+            .sort((left, right) => left.resetsAt - right.resetsAt)[0];
+        return {
+            healthy: usedPercent < 100,
+            usedPercent,
+            remainingPercent: resetWindow ? 100 - resetWindow.usedPercent : undefined,
+            resetAt: resetWindow?.resetsAt ?? undefined,
+            resetInMinutes: resetWindow?.resetsAt ? Math.max(0, Math.ceil((resetWindow.resetsAt * 1000 - now) / 60_000)) : undefined,
+            windows,
+        };
     }
     const credits = snapshot?.credits.find(item => item.id === provider)?.credits;
     if (credits?.available) {
@@ -34,6 +56,10 @@ export function workerCandidates(adapters, registered, snapshot) {
                 resourceHealthy: resource.healthy,
                 resourceProvider: provider,
                 resourceUsedPercent: resource.usedPercent,
+                resourceRemainingPercent: resource.remainingPercent,
+                resourceResetAt: resource.resetAt,
+                resourceResetInMinutes: resource.resetInMinutes,
+                resourceWindows: resource.windows,
             };
         });
     });
@@ -76,6 +102,10 @@ function selection(selected, selectedBy, decisionEvidence) {
         resourceHealthy: selected.resourceHealthy,
         resourceProvider: selected.resourceProvider,
         resourceUsedPercent: selected.resourceUsedPercent,
+        resourceRemainingPercent: selected.resourceRemainingPercent,
+        resourceResetAt: selected.resourceResetAt,
+        resourceResetInMinutes: selected.resourceResetInMinutes,
+        resourceWindows: selected.resourceWindows,
         decisionEvidence,
     };
 }
@@ -108,6 +138,10 @@ export async function routeWorker(candidates, requirements, options = {}) {
             resourceHealthy: item.resourceHealthy ?? null,
             resourceProvider: item.resourceProvider ?? null,
             resourceUsedPercent: item.resourceUsedPercent ?? null,
+            resourceRemainingPercent: item.resourceRemainingPercent ?? null,
+            resourceResetAt: item.resourceResetAt ?? null,
+            resourceResetInMinutes: item.resourceResetInMinutes ?? null,
+            resourceWindows: item.resourceWindows ?? null,
         })),
     }));
     const choice = await chooseWithDecision(options.decisionEngine, options.decisionMode ?? 'off', { facts }, { type: 'choice', question: 'Which eligible worker is best suited to execute this task?', choices: eligible.map(item => item.workerId) }, () => deterministic.workerId);

package/dist/workflow/definitions.js

@@ -1,18 +1,26 @@
 import { readFileSync } from 'node:fs';
 import { parseExecutableMermaid, WorkflowEngine } from './mermaid.js';
-import { WORKFLOW_EFFECT_NAMES, WORKFLOW_EVENT_NAMES, WORKFLOW_MUTATION_NAMES } from './contracts.js';
+import { WORKFLOW_EFFECT_NAMES, WORKFLOW_EVENT_NAMES, WORKFLOW_FACT_NAMES, WORKFLOW_MUTATION_NAMES, classifyWorkflowActions } from './contracts.js';
 function declarativeActions() {
     return Object.fromEntries([...WORKFLOW_MUTATION_NAMES, ...WORKFLOW_EFFECT_NAMES].map(name => [name, { declarative: true }]));
 }
-function load(name, guards = {}) {
-    const url = new URL(`../../workflow/${name}.mmd`, import.meta.url);
-    const graph = parseExecutableMermaid(readFileSync(url, 'utf8'));
+export function validateCanonicalWorkflowGraph(graph) {
     const canonicalEvents = new Set(WORKFLOW_EVENT_NAMES);
+    const canonicalFacts = new Set(WORKFLOW_FACT_NAMES);
     for (const transition of graph.transitions) {
         if (!canonicalEvents.has(transition.event)) {
             throw new Error(`Unknown canonical workflow event ${transition.event} referenced at line ${transition.line}`);
         }
+        if (transition.guard && !canonicalFacts.has(transition.guard)) {
+            throw new Error(`Unknown canonical workflow fact ${transition.guard} referenced at line ${transition.line}`);
+        }
+        classifyWorkflowActions(transition.actions);
     }
+}
+function load(name, guards = {}) {
+    const url = new URL(`../../workflow/${name}.mmd`, import.meta.url);
+    const graph = parseExecutableMermaid(readFileSync(url, 'utf8'));
+    validateCanonicalWorkflowGraph(graph);
     return new WorkflowEngine(graph, guards, declarativeActions());
 }
 const booleanGuard = (name) => context => context[name] === true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agents-relay",
-  "version": "1.0.101",
+  "version": "1.0.103",
   "description": "Durable async agent jobs coordinated through GitHub pull requests",
   "type": "module",
   "bin": {
@@ -9,7 +9,7 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.json && chmod +x dist/cli.js dist/relayd.js",
-    "test": "npm run build && node --test --test-force-exit test/*.test.js",
+    "test": "npm run build && node --test test/*.test.js",
     "test:chatgpt-temp-quality": "AGENTS_RELAY_RUN_CHATGPT_TEMP_QUALITY=1 AGENTS_RELAY_CHATGPT_BROWSER_WORKER_AGENT=/Users/chengli/Workspace/neo/skills/chatgpt-browser-worker/agents/browser-worker.agent.md sh -c \"npm run build && node test/quality/run-temporary-chat.mjs\"",
     "dev": "tsx src/cli.ts"
   },