agents-relay 2.0.100 → 2.0.102

package/dist/planner-runtime.js

@@ -80,7 +80,7 @@ async function finishPlanner(ports, jobId, planId, executionId, error, raw) {
                 return;
             const attempt = fresh.attempt ?? 0;
             const maxAttempts = fresh.maxAttempts ?? (fresh.manualPlanning ? 1 : 3);
-            retry = attempt < maxAttempts;
+            retry = attempt < maxAttempts && !message.startsWith('Planner JSON correction failed after one retry:');
             fresh.status = retry ? 'PLANNING' : 'FAILED';
             fresh.retryFeedback = message;
             fresh.error = message;

package/dist/planner.js

@@ -502,17 +502,14 @@ export class AgentObjectivePlanner {
         this.agentFile = agentFile;
     }
     async plan(context, signal) {
-        const resolvedPlanner = context.executionContext?.agents.find(agent => agent.name === 'planner')?.path;
         const effectivePlanner = context.executionContext ? await resolveAgentMarkdown('planner', BUNDLED_AGENTS_ROOT, context.executionContext.project.path) : undefined;
         const instructions = effectivePlanner?.content ?? await readFile(this.agentFile, 'utf8');
         const contract = await readFile(DEFAULT_TASK_JOB_CONTRACT, 'utf8');
         const resolvedContext = context.executionContext ? executionContextPrompt(context.executionContext) + '\n\n' : '';
         const prompt = (effectivePlanner ? `[Effective planner contract SHA-256: ${effectivePlanner.hash}]\n\n` : '') + instructions.trim() + '\n\n## Shared Task / Job Contract\n\n' + contract.trim() + '\n\n' + resolvedContext + '## Durable planner input\n\n' + plannerInput(context);
-        return await new Promise((resolve, reject) => {
-            const child = spawnOwnedProcess(this.command, ['exec', '--json', '--', prompt], { invocation: 'planner.agent', signal, correlation: { jobId: context.job.id }, spawn: { cwd: context.executionContext?.project.path, stdio: ['ignore', 'pipe', 'pipe'] } });
-            let stdoutBuffer = '';
-            let finalMessage = '';
-            let stderrTail = '';
+        const runAgent = (input) => new Promise((resolve, reject) => {
+            const child = spawnOwnedProcess(this.command, ['exec', '--json', '--', input], { invocation: 'planner.agent', signal, correlation: { jobId: context.job.id }, spawn: { cwd: context.executionContext?.project.path, stdio: ['ignore', 'pipe', 'pipe'] } });
+            let stdoutBuffer = '', finalMessage = '', stderrTail = '';
             const consume = (line) => {
                 const message = parsePlannerAgentMessage(line);
                 if (message)
@@ -538,13 +535,23 @@ export class AgentObjectivePlanner {
                     reject(new Error('Planner agent returned no final message'));
                     return;
                 }
-                try {
-                    resolve(parsePlannerOutput(finalMessage));
-                }
-                catch (error) {
-                    reject(error);
-                }
+                resolve(finalMessage);
             });
         });
+        const first = await runAgent(prompt);
+        try {
+            return parsePlannerOutput(first);
+        }
+        catch (error) {
+            if (signal.aborted)
+                throw error;
+            const correction = `${prompt}\n\n## Format correction (one retry only)\nYour previous final response was not valid Planner JSON. Error: ${error instanceof Error ? error.message : String(error)}\nPrevious response (possibly truncated):\n${first.slice(0, 12000)}\nReturn exactly one valid JSON object conforming to the Planner contract. No prose, no second JSON object.`;
+            try {
+                return parsePlannerOutput(await runAgent(correction));
+            }
+            catch (retryError) {
+                throw new Error(`Planner JSON correction failed after one retry: ${retryError instanceof Error ? retryError.message : String(retryError)}`);
+            }
+        }
     }
 }

package/dist/pool.js

@@ -5,6 +5,7 @@ import { scheduleBucket } from './scheduler.js';
 import { ReconcileCoordinator } from './reconcile-coordinator.js';
 import { errorMessage, observability, withObservabilityCorrelation } from './observability.js';
 import { jobHasActiveExecution } from './job-execution-slot.js';
+import { unconsumedUnblockTrigger } from './unblock.js';
 const RANK = { P0: 0, P1: 1, P2: 2, P3: 3 };
 export function compareJobPriority(a, b) { return RANK[a.priority ?? 'P2'] - RANK[b.priority ?? 'P2'] || a.createdAt.localeCompare(b.createdAt) || a.id.localeCompare(b.id); }
 export function runnableManagedJobs(items) { return items.filter(item => item.job.state === 'ACTIVE').map(item => item.job).sort(compareJobPriority); }
@@ -12,6 +13,8 @@ export function needsLifecycleReconciliation(job, now = Date.now()) {
     // DRAFT create-only Jobs stay dormant until a caller explicitly creates work.
     if (job.tasks.length === 0)
         return false;
+    if (job.executionMode === 'autonomous' && unconsumedUnblockTrigger(job))
+        return true;
     if (job.tasks.some(task => (task.state === 'QUEUED' && task.executionId === null)
         || (task.state === 'RUNNING' && task.adapter === 'orchestrator' && task.executionId === null)
         || (task.state === 'DRAFT' && task.dependencies.length > 0)))

package/dist/workflow/planner-orchestration-v2.js

@@ -1,7 +1,7 @@
 import { readFileSync } from 'node:fs';
 import { GraphRuntime } from './graph-v2.js';
 import { dispatchWorkflowGraph, dispatchWorkflowGraphSync } from './dispatcher.js';
-import { isEffectivelyBlocked } from '../unblock.js';
+import { isEffectivelyBlocked, unconsumedUnblockTrigger } from '../unblock.js';
 const source = readFileSync(new URL('../../workflow/planner-orchestration.mmd', import.meta.url), 'utf8');
 const boolGuard = (name) => (facts) => facts.durableFacts[name] === true;
 export const plannerOrchestrationV2 = new GraphRuntime(source, {
@@ -51,7 +51,7 @@ export function plannerOrchestrationFacts(job, recoverablePendingPlan) {
         recoverablePendingPlan,
         hasSeedWork: !((job.plans?.length ?? 0) === 0 && job.tasks.filter(task => task.kind !== 'planner').length === 0),
         noActivePlanner: !scopedPlans.some(plan => plan.status === 'PLANNING'),
-        noBlockedWork: !scopedTasks.some(task => task.kind !== 'planner' && isEffectivelyBlocked(task)),
+        noBlockedWork: Boolean(unconsumedUnblockTrigger(job)) || !scopedTasks.some(task => task.kind !== 'planner' && isEffectivelyBlocked(task)),
         noActiveImplementation: !scopedTasks.some(task => task.kind !== 'planner' && ['DRAFT', 'QUEUED', 'RUNNING'].includes(task.state)),
         resolutionOwnedByTroubleshooter: scopedTasks.some(task => task.kind !== 'planner' && task.resolution?.owner === 'troubleshooter' && ['active', 'waiting'].includes(task.resolution.state)),
         continuationMaterialized: !(latestObjective === 'in_progress' && latestId && !job.tasks.some(task => task.kind !== 'planner' && task.planningDecisionId === latestId)),

package/package.json

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