agents-relay 2.0.29 → 2.0.31

package/dist/cli-support.js

@@ -73,8 +73,15 @@ export async function relayControlJob(args, jobId) {
     if (!Number.isInteger(port) || port <= 0 || port > 65535)
         throw new Error('--port must be an integer between 1 and 65535');
     let response;
+    const params = new URLSearchParams({ id: jobId });
+    const repo = arg(args, '--repo');
+    const pr = Number(arg(args, '--pr'));
+    if (repo)
+        params.set('repo', repo);
+    if (Number.isInteger(pr) && pr > 0)
+        params.set('pr', String(pr));
     try {
-        response = await fetch(`http://${host}:${port}/api/job?id=${encodeURIComponent(jobId)}`);
+        response = await fetch(`http://${host}:${port}/api/job?${params.toString()}`);
     }
     catch (error) {
         throw new Error(`Agents Relay service unavailable at ${host}:${port}: ${error instanceof Error ? error.message : String(error)}`);

package/dist/dashboard.js

@@ -110,11 +110,11 @@ export function serveDashboard(store, port = 8787, bus, refreshMs = 300000, jobI
             }
         }
     };
-    const snapshot = async (requestedJobId = jobId, forceRefresh = false) => {
+    const snapshot = async (requestedJobId = jobId, forceRefresh = false, target) => {
         await subscribeDiscovered();
         if (overviewProvider) {
             if (forceRefresh && requestedJobId && resolvedExactJobProvider) {
-                const exact = await resolvedExactJobProvider(requestedJobId);
+                const exact = await resolvedExactJobProvider(requestedJobId, target);
                 if (exact)
                     return { id: exact.id, json: JSON.stringify(exact) };
             }
@@ -371,8 +371,12 @@ export function serveDashboard(store, port = 8787, bus, refreshMs = 300000, jobI
         }
         if (new URL(req.url ?? '/', 'http://127.0.0.1').pathname === '/api/job') {
             try {
-                const requestedJobId = new URL(req.url ?? '/', 'http://127.0.0.1').searchParams.get('id') ?? undefined;
-                const body = (await snapshot(requestedJobId, true)).json;
+                const url = new URL(req.url ?? '/', 'http://127.0.0.1');
+                const requestedJobId = url.searchParams.get('id') ?? undefined;
+                const repository = url.searchParams.get('repo') ?? undefined;
+                const parsedPr = Number(url.searchParams.get('pr'));
+                const prNumber = Number.isInteger(parsedPr) && parsedPr > 0 ? parsedPr : undefined;
+                const body = (await snapshot(requestedJobId, true, { repository, prNumber })).json;
                 if (!res.headersSent)
                     res.writeHead(200, { 'content-type': 'application/json' });
                 if (!res.writableEnded)

package/dist/relayd.js

@@ -320,10 +320,17 @@ export async function runDaemon(argv) {
             cachedOverviews = dashboardManagedJobs(cachedOverviews);
         }
     } : undefined;
-    const exactJob = async (jobId) => {
-        const cached = cachedOverviews.find(item => item.job.id === jobId);
+    const exactJob = async (jobId, target) => {
+        let cached = cachedOverviews.find(item => item.job.id === jobId);
+        if (!cached && target?.repository && target.prNumber && repositories.includes(target.repository)) {
+            cached = (await refreshPullRequest(target.repository, target.prNumber, 'control.job-lookup', { force: true })).find(item => item.job.id === jobId);
+        }
         if (!cached)
             return null;
+        if (target?.repository && cached.job.repository !== target.repository)
+            return null;
+        if (target?.prNumber && cached.job.prNumber !== target.prNumber)
+            return null;
         const cachedJob = () => ({ ...cached.job, githubState: cached.githubState, runtimeStatus: deriveJobRuntimeStatus(cached.job, cached.githubState), mergedAt: cached.mergedAt, closedAt: cached.closedAt, draft: cached.draft, publication: cached.publication });
         if (client.rateLimitStatus().limited)
             return cachedJob();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agents-relay",
-  "version": "2.0.29",
+  "version": "2.0.31",
   "description": "Durable async agent jobs coordinated through GitHub pull requests",
   "type": "module",
   "bin": {

package/skills/agents-relay/contracts/orchestrator-workflows.md

@@ -6,6 +6,25 @@ Before `job create`, the orchestrator converts the relevant discussion into a st
 
 This contract defines orchestrator-owned exception workflows that sit above normal Agents Relay task/job execution.
 
+## Normal managed Job start workflow
+
+For a normal managed Job, `job create` or `job adopt` establishes durable Job/PR state only. Unless the user explicitly requested **create-only / no execution**, the orchestrator must immediately start the Job by invoking the first-class Planner command for that exact Job:
+
+```text
+job create|adopt
+  -> agents-relay plan --repo <owner/repo> --pr <number> --id <job_id>
+  -> durable plan-N
+  -> Planner next_tasks
+  -> Relay materializes Tasks
+  -> normal routing, execution, and reconciliation
+```
+
+The initial decomposition for a normal managed Job belongs to that durable Planner round. The orchestrator must not hand-author the initial child Task batch as a substitute for `agents-relay plan`, and it must not leave a newly created executable Job with zero Plans and zero Tasks. If the Planner command fails, the Job is blocked at startup and the orchestrator must report the failure rather than silently inventing Tasks.
+
+This rule applies regardless of whether the Job uses `fixed` or `autonomous` execution mode; execution mode does not replace the required initial Planner invocation. Later replanning continues to follow Relay's normal Planner/reconciliation rules.
+
+The explicit exception is the P0/self-job workflow below: a self job is synchronous orchestrator-owned execution, so it creates orchestrator-owned Tasks directly and terminalizes them in the same turn instead of invoking the normal initial Planner round.
+
 ## P0 / self job workflow
 
 A **P0 job** (alias: **self job**) is executed directly by the current active orchestrator thread: