agent-relay 3.2.17 → 3.2.21

package/packages/sdk/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-relay/sdk",
-  "version": "3.2.17",
+  "version": "3.2.21",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -112,7 +112,7 @@
     "typescript": "^5.7.3"
   },
   "dependencies": {
-    "@agent-relay/config": "3.2.17",
+    "@agent-relay/config": "3.2.21",
     "@relaycast/sdk": "^1.1.0",
     "@sinclair/typebox": "^0.34.48",
     "chalk": "^4.1.2",

package/packages/sdk/src/__tests__/workflow-runner.test.ts

@@ -642,8 +642,7 @@ agents:
       );
 
       expect(ownerAssignments).toContainEqual({ owner: 'relay-worker', specialist: 'relay-worker' });
-      expect(run.status).toBe('failed');
-      expect(run.error).toContain('verification failed');
+      expect(run.status, run.error).toBe('completed');
 
       const spawnCalls = (mockRelayInstance.spawnPty as any).mock.calls;
       expect(spawnCalls).toHaveLength(1);
@@ -652,6 +651,78 @@ agents:
       expect(spawnCalls[0][0].name).not.toContain('-review-');
     });
 
+    it('should spill oversized interactive tasks to a temp file before PTY spawn', async () => {
+      const tmpDir = mkdtempSync(path.join(os.tmpdir(), 'relay-pty-task-'));
+      const oversizedBytes = WorkflowRunner.PTY_TASK_ARG_SIZE_LIMIT + 1024;
+      let spawnedTask = '';
+      let taskFilePath = '';
+      let taskFileContents = '';
+      runner = new WorkflowRunner({ db, workspaceId: 'ws-test', cwd: tmpDir });
+
+      mockRelayInstance.spawnPty.mockImplementation(
+        async ({ name, task }: { name: string; task?: string }) => {
+          spawnedTask = task ?? '';
+          const match = spawnedTask.match(/TASK_FILE:(.+)\n/);
+          if (match) {
+            taskFilePath = match[1].trim();
+            taskFileContents = readFileSync(taskFilePath, 'utf-8');
+          }
+
+          const output = mockSpawnOutputs.shift() ?? 'LEAD_DONE\n';
+          queueMicrotask(() => {
+            if (typeof mockRelayInstance.onWorkerOutput === 'function') {
+              mockRelayInstance.onWorkerOutput({ name, chunk: output });
+            }
+          });
+
+          return { ...mockAgent, name };
+        }
+      );
+
+      try {
+        mockSpawnOutputs = ['LEAD_DONE\n'];
+
+        const run = await runner.execute(
+          makeConfig({
+            agents: [{ name: 'team-lead', cli: 'claude', role: 'Lead coordinator' }],
+            workflows: [
+              {
+                name: 'default',
+                steps: [
+                  {
+                    name: 'prepare',
+                    type: 'deterministic',
+                    command: `node -e "process.stdout.write('A'.repeat(${oversizedBytes}))"`,
+                  },
+                  {
+                    name: 'lead-step',
+                    agent: 'team-lead',
+                    dependsOn: ['prepare'],
+                    task: 'Review the injected context below and then print LEAD_DONE:\n{{steps.prepare.output}}\n/exit',
+                    verification: { type: 'exit_code', value: 0 },
+                  },
+                ],
+              },
+            ],
+          }),
+          'default'
+        );
+
+        expect(run.status, run.error).toBe('completed');
+        expect(spawnedTask).toContain('TASK_FILE:');
+        expect(spawnedTask).not.toContain('{{steps.prepare.output}}');
+        expect(Buffer.byteLength(spawnedTask, 'utf8')).toBeLessThan(2048);
+        expect(taskFilePath).toBeTruthy();
+        expect(Buffer.byteLength(taskFileContents, 'utf8')).toBeGreaterThan(
+          WorkflowRunner.PTY_TASK_ARG_SIZE_LIMIT
+        );
+        expect(taskFileContents).toContain('Review the injected context below');
+        expect(existsSync(taskFilePath)).toBe(false);
+      } finally {
+        rmSync(tmpDir, { recursive: true, force: true });
+      }
+    });
+
     it('should pass canonical bypass args to interactive codex PTY spawns', async () => {
       mockSpawnOutputs = [
         'LEAD_DONE\n',

package/packages/sdk/src/workflows/__tests__/e2big-and-verify.test.ts

@@ -0,0 +1,117 @@
+import { describe, expect, it, vi } from 'vitest';
+
+vi.mock('@relaycast/sdk', () => ({
+  RelayCast: vi.fn(),
+  RelayError: class RelayError extends Error {},
+}));
+
+vi.mock('../../relay.js', () => ({
+  AgentRelay: vi.fn(),
+}));
+
+const { WorkflowRunner } = await import('../runner.js');
+
+describe('runVerification output_contains (token double-count fix)', () => {
+  function createRunner(): InstanceType<typeof WorkflowRunner> {
+    return new WorkflowRunner({ cwd: '/tmp/test' });
+  }
+
+  function runVerification(
+    runner: InstanceType<typeof WorkflowRunner>,
+    check: { type: 'output_contains'; value: string },
+    output: string,
+    stepName: string,
+    injectedTaskText?: string
+  ) {
+    return (runner as any).runVerification(check, output, stepName, injectedTaskText, {
+      allowFailure: true,
+    });
+  }
+
+  it('passes when token is in output and not in task injection', () => {
+    const runner = createRunner();
+    const result = runVerification(
+      runner,
+      { type: 'output_contains', value: 'DONE' },
+      'Task completed. DONE',
+      'step1'
+    );
+    expect(result.passed).toBe(true);
+  });
+
+  it('fails when token is missing from output entirely', () => {
+    const runner = createRunner();
+    const result = runVerification(
+      runner,
+      { type: 'output_contains', value: 'DONE' },
+      'Task completed without the marker',
+      'step1'
+    );
+    expect(result.passed).toBe(false);
+    expect(result.error).toContain('does not contain "DONE"');
+  });
+
+  it('passes when token is in both task injection and agent output', () => {
+    const runner = createRunner();
+    const result = runVerification(
+      runner,
+      { type: 'output_contains', value: 'REFLECTION_COMPLETE' },
+      'Your task: output REFLECTION_COMPLETE when done\n\nI have finished. REFLECTION_COMPLETE',
+      'step1',
+      'Your task: output REFLECTION_COMPLETE when done'
+    );
+    expect(result.passed).toBe(true);
+  });
+
+  it('fails when token appears only in task injection (not produced by agent)', () => {
+    const runner = createRunner();
+    const result = runVerification(
+      runner,
+      { type: 'output_contains', value: 'REFLECTION_COMPLETE' },
+      'Your task: output REFLECTION_COMPLETE when done\n\nI worked on it but forgot the marker.',
+      'step1',
+      'Your task: output REFLECTION_COMPLETE when done'
+    );
+    expect(result.passed).toBe(false);
+    expect(result.error).toContain('does not contain "REFLECTION_COMPLETE"');
+  });
+
+  it('handles token appearing multiple times in task injection', () => {
+    const runner = createRunner();
+    const taskText = 'Output DONE when done. Remember: DONE is required.';
+    const output = taskText + '\n\nAll work complete. DONE';
+    const result = runVerification(
+      runner,
+      { type: 'output_contains', value: 'DONE' },
+      output,
+      'step1',
+      taskText
+    );
+    expect(result.passed).toBe(true);
+  });
+
+  it('fails when token appears same number of times as in task injection', () => {
+    const runner = createRunner();
+    const taskText = 'Output DONE when done. Remember: DONE is required.';
+    const output = taskText + '\n\nAll work complete but no marker here.';
+    const result = runVerification(
+      runner,
+      { type: 'output_contains', value: 'DONE' },
+      output,
+      'step1',
+      taskText
+    );
+    expect(result.passed).toBe(false);
+  });
+
+  it('handles empty token gracefully', () => {
+    const runner = createRunner();
+    const result = runVerification(
+      runner,
+      { type: 'output_contains', value: '' },
+      'some output',
+      'step1'
+    );
+    expect(result.passed).toBe(false);
+  });
+});

package/packages/sdk/src/workflows/runner.ts

@@ -9,6 +9,7 @@ import { randomBytes } from 'node:crypto';
 import {
   createWriteStream,
   existsSync,
+  mkdtempSync,
   mkdirSync,
   readFileSync,
   readdirSync,
@@ -17,7 +18,8 @@ import {
   writeFileSync,
 } from 'node:fs';
 import type { Dirent, WriteStream } from 'node:fs';
-import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { readFile, writeFile, mkdir, unlink } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
 import path from 'node:path';
 import chalk from 'chalk';
 
@@ -97,6 +99,7 @@ interface SpawnResult {
   output: string;
   exitCode?: number;
   exitSignal?: string;
+  promptTaskText?: string;
 }
 
 /** Error carrying exit code/signal from a failed subprocess spawn. */
@@ -364,6 +367,7 @@ export class WorkflowRunner {
   private readonly activeReviewers = new Map<string, number>();
   /** Structured CLI session reports captured during the current run, keyed by step name. */
   private readonly agentReports = new Map<string, CliSessionReport>();
+  private static readonly PTY_TASK_ARG_SIZE_LIMIT = 2 * 1024 * 1024; // 2 MB
 
   constructor(options: WorkflowRunnerOptions = {}) {
     this.db = options.db ?? new InMemoryWorkflowDb();
@@ -3539,6 +3543,7 @@ export class WorkflowRunner {
         let ownerOutput: string;
         let ownerElapsed: number;
         let completionReason: WorkflowStepCompletionReason | undefined;
+        let promptTaskText: string | undefined;
 
         if (usesDedicatedOwner) {
           const result = await this.executeSupervisedAgentStep(
@@ -3592,6 +3597,12 @@ export class WorkflowRunner {
                   : undefined,
               });
           const output = typeof spawnResult === 'string' ? spawnResult : spawnResult.output;
+          promptTaskText =
+            typeof spawnResult === 'string'
+              ? effectiveOwner.interactive === false
+                ? undefined
+                : ownerTask
+              : spawnResult.promptTaskText ?? ownerTask;
           lastExitCode = typeof spawnResult === 'string' ? undefined : spawnResult.exitCode;
           lastExitSignal = typeof spawnResult === 'string' ? undefined : spawnResult.exitSignal;
           ownerElapsed = Date.now() - ownerStartTime;
@@ -3602,8 +3613,8 @@ export class WorkflowRunner {
                 step,
                 output,
                 output,
-                ownerTask,
-                resolvedTask
+                promptTaskText ?? ownerTask,
+                promptTaskText ?? ownerTask
               );
               completionReason = completionDecision.completionReason;
             } catch (error) {
@@ -3654,7 +3665,7 @@ export class WorkflowRunner {
             step.verification,
             specialistOutput,
             step.name,
-            effectiveOwner.interactive === false ? undefined : resolvedTask
+            promptTaskText
           );
           completionReason = verificationResult.completionReason;
         }
@@ -4028,7 +4039,14 @@ export class WorkflowRunner {
           detail: `Worker ${workerRuntimeName} exited`,
           raw: { worker: workerRuntimeName, exitCode: result.exitCode, exitSignal: result.exitSignal },
         });
-        if (step.verification?.type === 'output_contains' && result.output.includes(step.verification.value)) {
+        if (
+          step.verification?.type === 'output_contains' &&
+          this.outputContainsVerificationToken(
+            result.output,
+            step.verification.value,
+            result.promptTaskText
+          )
+        ) {
           this.log(
             `[${step.name}] Verification gate observed: output contains ${JSON.stringify(step.verification.value)}`
           );
@@ -4079,13 +4097,14 @@ export class WorkflowRunner {
       const ownerElapsed = Date.now() - ownerStartTime;
       const ownerOutput = ownerResultObj.output;
       this.log(`[${step.name}] Owner "${supervised.owner.name}" exited`);
-      const specialistOutput = (await workerPromise).output;
+      const workerResultObj = await workerPromise;
+      const specialistOutput = workerResultObj.output;
       const completionDecision = this.resolveOwnerCompletionDecision(
         step,
         ownerOutput,
         specialistOutput,
-        supervisorTask,
-        resolvedTask
+        ownerResultObj.promptTaskText ?? supervisorTask,
+        workerResultObj.promptTaskText ?? specialistTask
       );
       return {
         specialistOutput,
@@ -4359,6 +4378,10 @@ export class WorkflowRunner {
     injectedTaskText: string
   ): boolean {
     const marker = `STEP_COMPLETE:${step.name}`;
+    const strippedOutput = this.stripInjectedTaskEcho(output, injectedTaskText);
+    if (strippedOutput.includes(marker)) {
+      return true;
+    }
     const taskHasMarker = injectedTaskText.includes(marker);
     const first = output.indexOf(marker);
     if (first === -1) {
@@ -4448,6 +4471,65 @@ export class WorkflowRunner {
       .join('\n');
   }
 
+  private stripInjectedTaskEcho(output: string, injectedTaskText?: string): string {
+    if (!injectedTaskText) {
+      return output;
+    }
+
+    const candidates = [
+      injectedTaskText,
+      injectedTaskText.replace(/\r\n/g, '\n'),
+      injectedTaskText.replace(/\n/g, '\r\n'),
+    ].filter((candidate, index, all) => candidate.length > 0 && all.indexOf(candidate) === index);
+
+    for (const candidate of candidates) {
+      const start = output.indexOf(candidate);
+      if (start !== -1) {
+        return output.slice(0, start) + output.slice(start + candidate.length);
+      }
+    }
+
+    return output;
+  }
+
+  private outputContainsVerificationToken(
+    output: string,
+    token: string,
+    injectedTaskText?: string
+  ): boolean {
+    if (!token) {
+      return false;
+    }
+    return this.stripInjectedTaskEcho(output, injectedTaskText).includes(token);
+  }
+
+  private prepareInteractiveSpawnTask(
+    agentName: string,
+    taskText: string
+  ): { spawnTaskText: string; promptTaskText: string; taskTmpFile?: string } {
+    if (Buffer.byteLength(taskText, 'utf8') <= WorkflowRunner.PTY_TASK_ARG_SIZE_LIMIT) {
+      return {
+        spawnTaskText: taskText,
+        promptTaskText: taskText,
+      };
+    }
+
+    const taskTmpDir = mkdtempSync(path.join(tmpdir(), 'relay-pty-task-'));
+    const taskTmpFile = path.join(taskTmpDir, `${agentName}-${Date.now()}.txt`);
+    writeFileSync(taskTmpFile, taskText, { encoding: 'utf8', mode: 0o600, flag: 'wx' });
+    const promptTaskText =
+      `TASK_FILE:${taskTmpFile}\n` +
+      'Read that file completely before taking any action.\n' +
+      'Treat the file contents as the full workflow task and follow them exactly.\n' +
+      'Do not ask for the task again.';
+
+    return {
+      spawnTaskText: promptTaskText,
+      promptTaskText,
+      taskTmpFile,
+    };
+  }
+
   private firstMeaningfulLine(output: string): string | undefined {
     return output
       .split('\n')
@@ -5218,6 +5300,7 @@ export class WorkflowRunner {
       '(b) outputting the exact text "/exit" on its own line as a fallback. ' +
       'Do not wait for further input — terminate immediately after finishing. ' +
       'Do NOT spawn sub-agents unless the task explicitly requires it.';
+    const preparedTask = this.prepareInteractiveSpawnTask(agentName, taskWithExit);
 
     // Register PTY output listener before spawning so we capture everything
     this.ptyOutputBuffers.set(agentName, []);
@@ -5257,7 +5340,7 @@ export class WorkflowRunner {
         model: agentDef.constraints?.model,
         args: interactiveSpawnPolicy.args,
         channels: agentChannels,
-        task: taskWithExit,
+        task: preparedTask.spawnTaskText,
         idleThresholdSecs: agentDef.constraints?.idleThresholdSecs,
         cwd: agentCwd,
       });
@@ -5368,6 +5451,7 @@ export class WorkflowRunner {
         agentDef,
         step,
         timeoutMs,
+        preparedTask.promptTaskText,
         options.preserveOnIdle ?? this.shouldPreserveIdleSupervisor(agentDef, step, options.evidenceRole)
       );
 
@@ -5385,7 +5469,7 @@ export class WorkflowRunner {
             step.verification,
             ptyOutput,
             step.name,
-            undefined,
+            preparedTask.promptTaskText,
             { allowFailure: true }
           );
           if (verificationResult.passed) {
@@ -5446,6 +5530,9 @@ export class WorkflowRunner {
       this.unregisterWorker(agentName);
       this.supervisedRuntimeAgents.delete(agentName);
       this.runtimeStepAgents.delete(agentName);
+      if (preparedTask.taskTmpFile) {
+        await unlink(preparedTask.taskTmpFile).catch(() => undefined);
+      }
     }
 
     let output: string;
@@ -5480,6 +5567,7 @@ export class WorkflowRunner {
       output,
       exitCode: agent?.exitCode,
       exitSignal: agent?.exitSignal,
+      promptTaskText: preparedTask.promptTaskText,
     };
   }
 
@@ -5547,6 +5635,7 @@ export class WorkflowRunner {
     agentDef: AgentDefinition,
     step: WorkflowStep,
     timeoutMs?: number,
+    promptTaskText?: string,
     preserveIdleSupervisor = false
   ): Promise<'exited' | 'timeout' | 'released' | 'force-released'> {
     const nudgeConfig = this.currentConfig?.swarm.idleNudge;
@@ -5572,21 +5661,14 @@ export class WorkflowRunner {
         ]);
         if (result.kind === 'idle' && result.result === 'idle') {
           // Check verification before treating idle as complete.
-          // Mirror runVerification's double-occurrence guard: if the task text
-          // contains the token (from the prompt instruction), require a second
-          // occurrence from the agent's actual output to avoid false positives.
           if (step.verification && step.verification.type === 'output_contains') {
             const token = step.verification.value;
             const ptyOutput = (this.ptyOutputBuffers.get(agent.name) ?? []).join('');
-            const taskText = step.task ?? '';
-            const taskHasToken = taskText.includes(token);
-            let verificationPassed = true;
-            if (taskHasToken) {
-              const first = ptyOutput.indexOf(token);
-              verificationPassed = first !== -1 && ptyOutput.includes(token, first + token.length);
-            } else {
-              verificationPassed = ptyOutput.includes(token);
-            }
+            const verificationPassed = this.outputContainsVerificationToken(
+              ptyOutput,
+              token,
+              promptTaskText
+            );
             if (!verificationPassed) {
               // The broker fires agent_idle only once per idle transition.
               // If the agent is still working (will produce output then idle again),
@@ -5798,23 +5880,8 @@ export class WorkflowRunner {
 
     switch (check.type) {
       case 'output_contains': {
-        // Guard against false positives: the PTY captures the injected task text
-        // verbatim, so if the verification token appears in the task itself the
-        // check would pass immediately without the agent doing any real work.
-        // When the task contains the token, require a SECOND occurrence — one
-        // from the task injection and one from the agent's actual response.
         const token = check.value;
-        const taskHasToken = injectedTaskText ? injectedTaskText.includes(token) : false;
-        if (taskHasToken) {
-          const first = output.indexOf(token);
-          const hasSecond = first !== -1 && output.includes(token, first + token.length);
-          if (!hasSecond) {
-            return fail(
-              `Verification failed for "${stepName}": output does not contain "${token}" ` +
-                `(token found only in task injection — agent must output it explicitly)`
-            );
-          }
-        } else if (!output.includes(token)) {
+        if (!this.outputContainsVerificationToken(output, token, injectedTaskText)) {
           return fail(`Verification failed for "${stepName}": output does not contain "${token}"`);
         }
         break;

package/packages/sdk-py/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "agent-relay-sdk"
-version = "3.2.17"
+version = "3.2.21"
 description = "Python SDK for Agent Relay workflows"
 readme = "README.md"
 license = "Apache-2.0"

package/packages/sdk-swift/Sources/AgentRelaySDK/RelayObserver.swift

@@ -218,6 +218,8 @@ public final class RelayObserver: NSObject, URLSessionWebSocketDelegate, @unchec
     }
 
     private func _handleSocketError(_ error: Error) {
+        isConnectionReady = false
+
         guard reconnectAttempts < maxReconnectAttempts else {
             _connectionState = .disconnected
             let delegate = self.delegate

package/packages/telemetry/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-relay/telemetry",
-  "version": "3.2.17",
+  "version": "3.2.21",
   "description": "Anonymous telemetry for Agent Relay usage analytics",
   "type": "module",
   "main": "dist/index.js",

package/packages/trajectory/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-relay/trajectory",
-  "version": "3.2.17",
+  "version": "3.2.21",
   "description": "Trajectory integration utilities (trail/PDERO) for Relay",
   "type": "module",
   "main": "dist/index.js",
@@ -22,7 +22,7 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@agent-relay/config": "3.2.17"
+    "@agent-relay/config": "3.2.21"
   },
   "devDependencies": {
     "@types/node": "^22.19.3",

package/packages/user-directory/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-relay/user-directory",
-  "version": "3.2.17",
+  "version": "3.2.21",
   "description": "User directory service for agent-relay (per-user credential storage)",
   "type": "module",
   "main": "dist/index.js",
@@ -22,7 +22,7 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@agent-relay/utils": "3.2.17"
+    "@agent-relay/utils": "3.2.21"
   },
   "devDependencies": {
     "@types/node": "^22.19.3",

package/packages/utils/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-relay/utils",
-  "version": "3.2.17",
+  "version": "3.2.21",
   "description": "Shared utilities for agent-relay: logging, name generation, command resolution, update checking",
   "type": "module",
   "main": "dist/cjs/index.js",
@@ -112,7 +112,7 @@
     "vitest": "^3.2.4"
   },
   "dependencies": {
-    "@agent-relay/config": "3.2.17",
+    "@agent-relay/config": "3.2.21",
     "compare-versions": "^6.1.1"
   },
   "publishConfig": {